?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] pata_jmicron: fix JMB368 support, add suspend/resume handling
[linux-2.6/x86.git] / fs / cifs / file.c
blob2436ed8fc8400e2d86b4e5bbb569b122ac013e34
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 * Jeremy Allison (jra@samba.org)
9 *
10 * This library is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU Lesser General Public License as published
12 * by the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24 #include <linux/fs.h>
25 #include <linux/backing-dev.h>
26 #include <linux/stat.h>
27 #include <linux/fcntl.h>
28 #include <linux/pagemap.h>
29 #include <linux/pagevec.h>
30 #include <linux/smp_lock.h>
31 #include <linux/writeback.h>
32 #include <linux/delay.h>
33 #include <asm/div64.h>
34 #include "cifsfs.h"
35 #include "cifspdu.h"
36 #include "cifsglob.h"
37 #include "cifsproto.h"
38 #include "cifs_unicode.h"
39 #include "cifs_debug.h"
40 #include "cifs_fs_sb.h"
41
42 static inline struct cifsFileInfo *cifs_init_private(
43 struct cifsFileInfo *private_data, struct inode *inode,
44 struct file *file, __u16 netfid)
45 {
46 memset(private_data, 0, sizeof(struct cifsFileInfo));
47 private_data->netfid = netfid;
48 private_data->pid = current->tgid;
49 init_MUTEX(&private_data->fh_sem);
50 init_MUTEX(&private_data->lock_sem);
51 INIT_LIST_HEAD(&private_data->llist);
52 private_data->pfile = file; /* needed for writepage */
53 private_data->pInode = inode;
54 private_data->invalidHandle = FALSE;
55 private_data->closePend = FALSE;
56 /* we have to track num writers to the inode, since writepages
57 does not tell us which handle the write is for so there can
58 be a close (overlapping with write) of the filehandle that
59 cifs_writepages chose to use */
60 atomic_set(&private_data->wrtPending,0);
61
62 return private_data;
63 }
64
65 static inline int cifs_convert_flags(unsigned int flags)
66 {
67 if ((flags & O_ACCMODE) == O_RDONLY)
68 return GENERIC_READ;
69 else if ((flags & O_ACCMODE) == O_WRONLY)
70 return GENERIC_WRITE;
71 else if ((flags & O_ACCMODE) == O_RDWR) {
72 /* GENERIC_ALL is too much permission to request
73 can cause unnecessary access denied on create */
74 /* return GENERIC_ALL; */
75 return (GENERIC_READ | GENERIC_WRITE);
76 }
77
78 return 0x20197;
79 }
80
81 static inline int cifs_get_disposition(unsigned int flags)
82 {
83 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
84 return FILE_CREATE;
85 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
86 return FILE_OVERWRITE_IF;
87 else if ((flags & O_CREAT) == O_CREAT)
88 return FILE_OPEN_IF;
89 else if ((flags & O_TRUNC) == O_TRUNC)
90 return FILE_OVERWRITE;
91 else
92 return FILE_OPEN;
93 }
94
95 /* all arguments to this function must be checked for validity in caller */
96 static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
97 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
98 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
99 char *full_path, int xid)
100 {
101 struct timespec temp;
102 int rc;
103
104 /* want handles we can use to read with first
105 in the list so we do not have to walk the
106 list to search for one in prepare_write */
107 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
108 list_add_tail(&pCifsFile->flist,
109 &pCifsInode->openFileList);
110 } else {
111 list_add(&pCifsFile->flist,
112 &pCifsInode->openFileList);
113 }
114 write_unlock(&GlobalSMBSeslock);
115 if (pCifsInode->clientCanCacheRead) {
116 /* we have the inode open somewhere else
117 no need to discard cache data */
118 goto client_can_cache;
119 }
120
121 /* BB need same check in cifs_create too? */
122 /* if not oplocked, invalidate inode pages if mtime or file
123 size changed */
124 temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
125 if (timespec_equal(&file->f_dentry->d_inode->i_mtime, &temp) &&
126 (file->f_dentry->d_inode->i_size ==
127 (loff_t)le64_to_cpu(buf->EndOfFile))) {
128 cFYI(1, ("inode unchanged on server"));
129 } else {
130 if (file->f_dentry->d_inode->i_mapping) {
131 /* BB no need to lock inode until after invalidate
132 since namei code should already have it locked? */
133 filemap_write_and_wait(file->f_dentry->d_inode->i_mapping);
134 }
135 cFYI(1, ("invalidating remote inode since open detected it "
136 "changed"));
137 invalidate_remote_inode(file->f_dentry->d_inode);
138 }
139
140 client_can_cache:
141 if (pTcon->ses->capabilities & CAP_UNIX)
142 rc = cifs_get_inode_info_unix(&file->f_dentry->d_inode,
143 full_path, inode->i_sb, xid);
144 else
145 rc = cifs_get_inode_info(&file->f_dentry->d_inode,
146 full_path, buf, inode->i_sb, xid);
147
148 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
149 pCifsInode->clientCanCacheAll = TRUE;
150 pCifsInode->clientCanCacheRead = TRUE;
151 cFYI(1, ("Exclusive Oplock granted on inode %p",
152 file->f_dentry->d_inode));
153 } else if ((*oplock & 0xF) == OPLOCK_READ)
154 pCifsInode->clientCanCacheRead = TRUE;
155
156 return rc;
157 }
158
159 int cifs_open(struct inode *inode, struct file *file)
160 {
161 int rc = -EACCES;
162 int xid, oplock;
163 struct cifs_sb_info *cifs_sb;
164 struct cifsTconInfo *pTcon;
165 struct cifsFileInfo *pCifsFile;
166 struct cifsInodeInfo *pCifsInode;
167 struct list_head *tmp;
168 char *full_path = NULL;
169 int desiredAccess;
170 int disposition;
171 __u16 netfid;
172 FILE_ALL_INFO *buf = NULL;
173
174 xid = GetXid();
175
176 cifs_sb = CIFS_SB(inode->i_sb);
177 pTcon = cifs_sb->tcon;
178
179 if (file->f_flags & O_CREAT) {
180 /* search inode for this file and fill in file->private_data */
181 pCifsInode = CIFS_I(file->f_dentry->d_inode);
182 read_lock(&GlobalSMBSeslock);
183 list_for_each(tmp, &pCifsInode->openFileList) {
184 pCifsFile = list_entry(tmp, struct cifsFileInfo,
185 flist);
186 if ((pCifsFile->pfile == NULL) &&
187 (pCifsFile->pid == current->tgid)) {
188 /* mode set in cifs_create */
189
190 /* needed for writepage */
191 pCifsFile->pfile = file;
192
193 file->private_data = pCifsFile;
194 break;
195 }
196 }
197 read_unlock(&GlobalSMBSeslock);
198 if (file->private_data != NULL) {
199 rc = 0;
200 FreeXid(xid);
201 return rc;
202 } else {
203 if (file->f_flags & O_EXCL)
204 cERROR(1, ("could not find file instance for "
205 "new file %p", file));
206 }
207 }
208
209 full_path = build_path_from_dentry(file->f_dentry);
210 if (full_path == NULL) {
211 FreeXid(xid);
212 return -ENOMEM;
213 }
214
215 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
216 inode, file->f_flags, full_path));
217 desiredAccess = cifs_convert_flags(file->f_flags);
218
219 /*********************************************************************
220 * open flag mapping table:
221 *
222 * POSIX Flag CIFS Disposition
223 * ---------- ----------------
224 * O_CREAT FILE_OPEN_IF
225 * O_CREAT | O_EXCL FILE_CREATE
226 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
227 * O_TRUNC FILE_OVERWRITE
228 * none of the above FILE_OPEN
229 *
230 * Note that there is not a direct match between disposition
231 * FILE_SUPERSEDE (ie create whether or not file exists although
232 * O_CREAT | O_TRUNC is similar but truncates the existing
233 * file rather than creating a new file as FILE_SUPERSEDE does
234 * (which uses the attributes / metadata passed in on open call)
235 *?
236 *? O_SYNC is a reasonable match to CIFS writethrough flag
237 *? and the read write flags match reasonably. O_LARGEFILE
238 *? is irrelevant because largefile support is always used
239 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
240 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
241 *********************************************************************/
242
243 disposition = cifs_get_disposition(file->f_flags);
244
245 if (oplockEnabled)
246 oplock = REQ_OPLOCK;
247 else
248 oplock = FALSE;
249
250 /* BB pass O_SYNC flag through on file attributes .. BB */
251
252 /* Also refresh inode by passing in file_info buf returned by SMBOpen
253 and calling get_inode_info with returned buf (at least helps
254 non-Unix server case) */
255
256 /* BB we can not do this if this is the second open of a file
257 and the first handle has writebehind data, we might be
258 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
259 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
260 if (!buf) {
261 rc = -ENOMEM;
262 goto out;
263 }
264
265 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
266 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition,
267 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
268 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
269 & CIFS_MOUNT_MAP_SPECIAL_CHR);
270 else
271 rc = -EIO; /* no NT SMB support fall into legacy open below */
272
273 if (rc == -EIO) {
274 /* Old server, try legacy style OpenX */
275 rc = SMBLegacyOpen(xid, pTcon, full_path, disposition,
276 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
277 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
278 & CIFS_MOUNT_MAP_SPECIAL_CHR);
279 }
280 if (rc) {
281 cFYI(1, ("cifs_open returned 0x%x", rc));
282 goto out;
283 }
284 file->private_data =
285 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
286 if (file->private_data == NULL) {
287 rc = -ENOMEM;
288 goto out;
289 }
290 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
291 write_lock(&GlobalSMBSeslock);
292 list_add(&pCifsFile->tlist, &pTcon->openFileList);
293
294 pCifsInode = CIFS_I(file->f_dentry->d_inode);
295 if (pCifsInode) {
296 rc = cifs_open_inode_helper(inode, file, pCifsInode,
297 pCifsFile, pTcon,
298 &oplock, buf, full_path, xid);
299 } else {
300 write_unlock(&GlobalSMBSeslock);
301 }
302
303 if (oplock & CIFS_CREATE_ACTION) {
304 /* time to set mode which we can not set earlier due to
305 problems creating new read-only files */
306 if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
307 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
308 inode->i_mode,
309 (__u64)-1, (__u64)-1, 0 /* dev */,
310 cifs_sb->local_nls,
311 cifs_sb->mnt_cifs_flags &
312 CIFS_MOUNT_MAP_SPECIAL_CHR);
313 } else {
314 /* BB implement via Windows security descriptors eg
315 CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
316 -1, -1, local_nls);
317 in the meantime could set r/o dos attribute when
318 perms are eg: mode & 0222 == 0 */
319 }
320 }
321
322 out:
323 kfree(buf);
324 kfree(full_path);
325 FreeXid(xid);
326 return rc;
327 }
328
329 /* Try to reacquire byte range locks that were released when session */
330 /* to server was lost */
331 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
332 {
333 int rc = 0;
334
335 /* BB list all locks open on this file and relock */
336
337 return rc;
338 }
339
340 static int cifs_reopen_file(struct inode *inode, struct file *file,
341 int can_flush)
342 {
343 int rc = -EACCES;
344 int xid, oplock;
345 struct cifs_sb_info *cifs_sb;
346 struct cifsTconInfo *pTcon;
347 struct cifsFileInfo *pCifsFile;
348 struct cifsInodeInfo *pCifsInode;
349 char *full_path = NULL;
350 int desiredAccess;
351 int disposition = FILE_OPEN;
352 __u16 netfid;
353
354 if (inode == NULL)
355 return -EBADF;
356 if (file->private_data) {
357 pCifsFile = (struct cifsFileInfo *)file->private_data;
358 } else
359 return -EBADF;
360
361 xid = GetXid();
362 down(&pCifsFile->fh_sem);
363 if (pCifsFile->invalidHandle == FALSE) {
364 up(&pCifsFile->fh_sem);
365 FreeXid(xid);
366 return 0;
367 }
368
369 if (file->f_dentry == NULL) {
370 up(&pCifsFile->fh_sem);
371 cFYI(1, ("failed file reopen, no valid name if dentry freed"));
372 FreeXid(xid);
373 return -EBADF;
374 }
375 cifs_sb = CIFS_SB(inode->i_sb);
376 pTcon = cifs_sb->tcon;
377 /* can not grab rename sem here because various ops, including
378 those that already have the rename sem can end up causing writepage
379 to get called and if the server was down that means we end up here,
380 and we can never tell if the caller already has the rename_sem */
381 full_path = build_path_from_dentry(file->f_dentry);
382 if (full_path == NULL) {
383 up(&pCifsFile->fh_sem);
384 FreeXid(xid);
385 return -ENOMEM;
386 }
387
388 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
389 inode, file->f_flags,full_path));
390 desiredAccess = cifs_convert_flags(file->f_flags);
391
392 if (oplockEnabled)
393 oplock = REQ_OPLOCK;
394 else
395 oplock = FALSE;
396
397 /* Can not refresh inode by passing in file_info buf to be returned
398 by SMBOpen and then calling get_inode_info with returned buf
399 since file might have write behind data that needs to be flushed
400 and server version of file size can be stale. If we knew for sure
401 that inode was not dirty locally we could do this */
402
403 /* buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
404 if (buf == 0) {
405 up(&pCifsFile->fh_sem);
406 kfree(full_path);
407 FreeXid(xid);
408 return -ENOMEM;
409 } */
410 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
411 CREATE_NOT_DIR, &netfid, &oplock, NULL,
412 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
413 CIFS_MOUNT_MAP_SPECIAL_CHR);
414 if (rc) {
415 up(&pCifsFile->fh_sem);
416 cFYI(1, ("cifs_open returned 0x%x", rc));
417 cFYI(1, ("oplock: %d", oplock));
418 } else {
419 pCifsFile->netfid = netfid;
420 pCifsFile->invalidHandle = FALSE;
421 up(&pCifsFile->fh_sem);
422 pCifsInode = CIFS_I(inode);
423 if (pCifsInode) {
424 if (can_flush) {
425 filemap_write_and_wait(inode->i_mapping);
426 /* temporarily disable caching while we
427 go to server to get inode info */
428 pCifsInode->clientCanCacheAll = FALSE;
429 pCifsInode->clientCanCacheRead = FALSE;
430 if (pTcon->ses->capabilities & CAP_UNIX)
431 rc = cifs_get_inode_info_unix(&inode,
432 full_path, inode->i_sb, xid);
433 else
434 rc = cifs_get_inode_info(&inode,
435 full_path, NULL, inode->i_sb,
436 xid);
437 } /* else we are writing out data to server already
438 and could deadlock if we tried to flush data, and
439 since we do not know if we have data that would
440 invalidate the current end of file on the server
441 we can not go to the server to get the new inod
442 info */
443 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
444 pCifsInode->clientCanCacheAll = TRUE;
445 pCifsInode->clientCanCacheRead = TRUE;
446 cFYI(1, ("Exclusive Oplock granted on inode %p",
447 file->f_dentry->d_inode));
448 } else if ((oplock & 0xF) == OPLOCK_READ) {
449 pCifsInode->clientCanCacheRead = TRUE;
450 pCifsInode->clientCanCacheAll = FALSE;
451 } else {
452 pCifsInode->clientCanCacheRead = FALSE;
453 pCifsInode->clientCanCacheAll = FALSE;
454 }
455 cifs_relock_file(pCifsFile);
456 }
457 }
458
459 kfree(full_path);
460 FreeXid(xid);
461 return rc;
462 }
463
464 int cifs_close(struct inode *inode, struct file *file)
465 {
466 int rc = 0;
467 int xid;
468 struct cifs_sb_info *cifs_sb;
469 struct cifsTconInfo *pTcon;
470 struct cifsFileInfo *pSMBFile =
471 (struct cifsFileInfo *)file->private_data;
472
473 xid = GetXid();
474
475 cifs_sb = CIFS_SB(inode->i_sb);
476 pTcon = cifs_sb->tcon;
477 if (pSMBFile) {
478 struct cifsLockInfo *li, *tmp;
479
480 pSMBFile->closePend = TRUE;
481 if (pTcon) {
482 /* no sense reconnecting to close a file that is
483 already closed */
484 if (pTcon->tidStatus != CifsNeedReconnect) {
485 int timeout = 2;
486 while((atomic_read(&pSMBFile->wrtPending) != 0)
487 && (timeout < 1000) ) {
488 /* Give write a better chance to get to
489 server ahead of the close. We do not
490 want to add a wait_q here as it would
491 increase the memory utilization as
492 the struct would be in each open file,
493 but this should give enough time to
494 clear the socket */
495 #ifdef CONFIG_CIFS_DEBUG2
496 cFYI(1,("close delay, write pending"));
497 #endif /* DEBUG2 */
498 msleep(timeout);
499 timeout *= 4;
500 }
501 if(atomic_read(&pSMBFile->wrtPending))
502 cERROR(1,("close with pending writes"));
503 rc = CIFSSMBClose(xid, pTcon,
504 pSMBFile->netfid);
505 }
506 }
507
508 /* Delete any outstanding lock records.
509 We'll lose them when the file is closed anyway. */
510 down(&pSMBFile->lock_sem);
511 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
512 list_del(&li->llist);
513 kfree(li);
514 }
515 up(&pSMBFile->lock_sem);
516
517 write_lock(&GlobalSMBSeslock);
518 list_del(&pSMBFile->flist);
519 list_del(&pSMBFile->tlist);
520 write_unlock(&GlobalSMBSeslock);
521 kfree(pSMBFile->search_resume_name);
522 kfree(file->private_data);
523 file->private_data = NULL;
524 } else
525 rc = -EBADF;
526
527 if (list_empty(&(CIFS_I(inode)->openFileList))) {
528 cFYI(1, ("closing last open instance for inode %p", inode));
529 /* if the file is not open we do not know if we can cache info
530 on this inode, much less write behind and read ahead */
531 CIFS_I(inode)->clientCanCacheRead = FALSE;
532 CIFS_I(inode)->clientCanCacheAll = FALSE;
533 }
534 if ((rc ==0) && CIFS_I(inode)->write_behind_rc)
535 rc = CIFS_I(inode)->write_behind_rc;
536 FreeXid(xid);
537 return rc;
538 }
539
540 int cifs_closedir(struct inode *inode, struct file *file)
541 {
542 int rc = 0;
543 int xid;
544 struct cifsFileInfo *pCFileStruct =
545 (struct cifsFileInfo *)file->private_data;
546 char *ptmp;
547
548 cFYI(1, ("Closedir inode = 0x%p", inode));
549
550 xid = GetXid();
551
552 if (pCFileStruct) {
553 struct cifsTconInfo *pTcon;
554 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_dentry->d_sb);
555
556 pTcon = cifs_sb->tcon;
557
558 cFYI(1, ("Freeing private data in close dir"));
559 if ((pCFileStruct->srch_inf.endOfSearch == FALSE) &&
560 (pCFileStruct->invalidHandle == FALSE)) {
561 pCFileStruct->invalidHandle = TRUE;
562 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
563 cFYI(1, ("Closing uncompleted readdir with rc %d",
564 rc));
565 /* not much we can do if it fails anyway, ignore rc */
566 rc = 0;
567 }
568 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
569 if (ptmp) {
570 cFYI(1, ("closedir free smb buf in srch struct"));
571 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
572 if(pCFileStruct->srch_inf.smallBuf)
573 cifs_small_buf_release(ptmp);
574 else
575 cifs_buf_release(ptmp);
576 }
577 ptmp = pCFileStruct->search_resume_name;
578 if (ptmp) {
579 cFYI(1, ("closedir free resume name"));
580 pCFileStruct->search_resume_name = NULL;
581 kfree(ptmp);
582 }
583 kfree(file->private_data);
584 file->private_data = NULL;
585 }
586 /* BB can we lock the filestruct while this is going on? */
587 FreeXid(xid);
588 return rc;
589 }
590
591 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
592 __u64 offset, __u8 lockType)
593 {
594 struct cifsLockInfo *li = kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
595 if (li == NULL)
596 return -ENOMEM;
597 li->offset = offset;
598 li->length = len;
599 li->type = lockType;
600 down(&fid->lock_sem);
601 list_add(&li->llist, &fid->llist);
602 up(&fid->lock_sem);
603 return 0;
604 }
605
606 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
607 {
608 int rc, xid;
609 __u32 numLock = 0;
610 __u32 numUnlock = 0;
611 __u64 length;
612 int wait_flag = FALSE;
613 struct cifs_sb_info *cifs_sb;
614 struct cifsTconInfo *pTcon;
615 __u16 netfid;
616 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
617 int posix_locking;
618
619 length = 1 + pfLock->fl_end - pfLock->fl_start;
620 rc = -EACCES;
621 xid = GetXid();
622
623 cFYI(1, ("Lock parm: 0x%x flockflags: "
624 "0x%x flocktype: 0x%x start: %lld end: %lld",
625 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
626 pfLock->fl_end));
627
628 if (pfLock->fl_flags & FL_POSIX)
629 cFYI(1, ("Posix"));
630 if (pfLock->fl_flags & FL_FLOCK)
631 cFYI(1, ("Flock"));
632 if (pfLock->fl_flags & FL_SLEEP) {
633 cFYI(1, ("Blocking lock"));
634 wait_flag = TRUE;
635 }
636 if (pfLock->fl_flags & FL_ACCESS)
637 cFYI(1, ("Process suspended by mandatory locking - "
638 "not implemented yet"));
639 if (pfLock->fl_flags & FL_LEASE)
640 cFYI(1, ("Lease on file - not implemented yet"));
641 if (pfLock->fl_flags &
642 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
643 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
644
645 if (pfLock->fl_type == F_WRLCK) {
646 cFYI(1, ("F_WRLCK "));
647 numLock = 1;
648 } else if (pfLock->fl_type == F_UNLCK) {
649 cFYI(1, ("F_UNLCK"));
650 numUnlock = 1;
651 /* Check if unlock includes more than
652 one lock range */
653 } else if (pfLock->fl_type == F_RDLCK) {
654 cFYI(1, ("F_RDLCK"));
655 lockType |= LOCKING_ANDX_SHARED_LOCK;
656 numLock = 1;
657 } else if (pfLock->fl_type == F_EXLCK) {
658 cFYI(1, ("F_EXLCK"));
659 numLock = 1;
660 } else if (pfLock->fl_type == F_SHLCK) {
661 cFYI(1, ("F_SHLCK"));
662 lockType |= LOCKING_ANDX_SHARED_LOCK;
663 numLock = 1;
664 } else
665 cFYI(1, ("Unknown type of lock"));
666
667 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
668 pTcon = cifs_sb->tcon;
669
670 if (file->private_data == NULL) {
671 FreeXid(xid);
672 return -EBADF;
673 }
674 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
675
676 posix_locking = (cifs_sb->tcon->ses->capabilities & CAP_UNIX) &&
677 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(cifs_sb->tcon->fsUnixInfo.Capability));
678
679 /* BB add code here to normalize offset and length to
680 account for negative length which we can not accept over the
681 wire */
682 if (IS_GETLK(cmd)) {
683 if(posix_locking) {
684 int posix_lock_type;
685 if(lockType & LOCKING_ANDX_SHARED_LOCK)
686 posix_lock_type = CIFS_RDLCK;
687 else
688 posix_lock_type = CIFS_WRLCK;
689 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 1 /* get */,
690 length, pfLock,
691 posix_lock_type, wait_flag);
692 FreeXid(xid);
693 return rc;
694 }
695
696 /* BB we could chain these into one lock request BB */
697 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
698 0, 1, lockType, 0 /* wait flag */ );
699 if (rc == 0) {
700 rc = CIFSSMBLock(xid, pTcon, netfid, length,
701 pfLock->fl_start, 1 /* numUnlock */ ,
702 0 /* numLock */ , lockType,
703 0 /* wait flag */ );
704 pfLock->fl_type = F_UNLCK;
705 if (rc != 0)
706 cERROR(1, ("Error unlocking previously locked "
707 "range %d during test of lock", rc));
708 rc = 0;
709
710 } else {
711 /* if rc == ERR_SHARING_VIOLATION ? */
712 rc = 0; /* do not change lock type to unlock
713 since range in use */
714 }
715
716 FreeXid(xid);
717 return rc;
718 }
719
720 if (!numLock && !numUnlock) {
721 /* if no lock or unlock then nothing
722 to do since we do not know what it is */
723 FreeXid(xid);
724 return -EOPNOTSUPP;
725 }
726
727 if (posix_locking) {
728 int posix_lock_type;
729 if(lockType & LOCKING_ANDX_SHARED_LOCK)
730 posix_lock_type = CIFS_RDLCK;
731 else
732 posix_lock_type = CIFS_WRLCK;
733
734 if(numUnlock == 1)
735 posix_lock_type = CIFS_UNLCK;
736
737 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 0 /* set */,
738 length, pfLock,
739 posix_lock_type, wait_flag);
740 } else {
741 struct cifsFileInfo *fid = (struct cifsFileInfo *)file->private_data;
742
743 if (numLock) {
744 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
745 0, numLock, lockType, wait_flag);
746
747 if (rc == 0) {
748 /* For Windows locks we must store them. */
749 rc = store_file_lock(fid, length,
750 pfLock->fl_start, lockType);
751 }
752 } else if (numUnlock) {
753 /* For each stored lock that this unlock overlaps
754 completely, unlock it. */
755 int stored_rc = 0;
756 struct cifsLockInfo *li, *tmp;
757
758 rc = 0;
759 down(&fid->lock_sem);
760 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
761 if (pfLock->fl_start <= li->offset &&
762 length >= li->length) {
763 stored_rc = CIFSSMBLock(xid, pTcon, netfid,
764 li->length, li->offset,
765 1, 0, li->type, FALSE);
766 if (stored_rc)
767 rc = stored_rc;
768
769 list_del(&li->llist);
770 kfree(li);
771 }
772 }
773 up(&fid->lock_sem);
774 }
775 }
776
777 if (pfLock->fl_flags & FL_POSIX)
778 posix_lock_file_wait(file, pfLock);
779 FreeXid(xid);
780 return rc;
781 }
782
783 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
784 size_t write_size, loff_t *poffset)
785 {
786 int rc = 0;
787 unsigned int bytes_written = 0;
788 unsigned int total_written;
789 struct cifs_sb_info *cifs_sb;
790 struct cifsTconInfo *pTcon;
791 int xid, long_op;
792 struct cifsFileInfo *open_file;
793
794 if (file->f_dentry == NULL)
795 return -EBADF;
796
797 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
798 if (cifs_sb == NULL)
799 return -EBADF;
800
801 pTcon = cifs_sb->tcon;
802
803 /* cFYI(1,
804 (" write %d bytes to offset %lld of %s", write_size,
805 *poffset, file->f_dentry->d_name.name)); */
806
807 if (file->private_data == NULL)
808 return -EBADF;
809 else
810 open_file = (struct cifsFileInfo *) file->private_data;
811
812 xid = GetXid();
813 if (file->f_dentry->d_inode == NULL) {
814 FreeXid(xid);
815 return -EBADF;
816 }
817
818 if (*poffset > file->f_dentry->d_inode->i_size)
819 long_op = 2; /* writes past end of file can take a long time */
820 else
821 long_op = 1;
822
823 for (total_written = 0; write_size > total_written;
824 total_written += bytes_written) {
825 rc = -EAGAIN;
826 while (rc == -EAGAIN) {
827 if (file->private_data == NULL) {
828 /* file has been closed on us */
829 FreeXid(xid);
830 /* if we have gotten here we have written some data
831 and blocked, and the file has been freed on us while
832 we blocked so return what we managed to write */
833 return total_written;
834 }
835 if (open_file->closePend) {
836 FreeXid(xid);
837 if (total_written)
838 return total_written;
839 else
840 return -EBADF;
841 }
842 if (open_file->invalidHandle) {
843 if ((file->f_dentry == NULL) ||
844 (file->f_dentry->d_inode == NULL)) {
845 FreeXid(xid);
846 return total_written;
847 }
848 /* we could deadlock if we called
849 filemap_fdatawait from here so tell
850 reopen_file not to flush data to server
851 now */
852 rc = cifs_reopen_file(file->f_dentry->d_inode,
853 file, FALSE);
854 if (rc != 0)
855 break;
856 }
857
858 rc = CIFSSMBWrite(xid, pTcon,
859 open_file->netfid,
860 min_t(const int, cifs_sb->wsize,
861 write_size - total_written),
862 *poffset, &bytes_written,
863 NULL, write_data + total_written, long_op);
864 }
865 if (rc || (bytes_written == 0)) {
866 if (total_written)
867 break;
868 else {
869 FreeXid(xid);
870 return rc;
871 }
872 } else
873 *poffset += bytes_written;
874 long_op = FALSE; /* subsequent writes fast -
875 15 seconds is plenty */
876 }
877
878 cifs_stats_bytes_written(pTcon, total_written);
879
880 /* since the write may have blocked check these pointers again */
881 if (file->f_dentry) {
882 if (file->f_dentry->d_inode) {
883 struct inode *inode = file->f_dentry->d_inode;
884 inode->i_ctime = inode->i_mtime =
885 current_fs_time(inode->i_sb);
886 if (total_written > 0) {
887 if (*poffset > file->f_dentry->d_inode->i_size)
888 i_size_write(file->f_dentry->d_inode,
889 *poffset);
890 }
891 mark_inode_dirty_sync(file->f_dentry->d_inode);
892 }
893 }
894 FreeXid(xid);
895 return total_written;
896 }
897
898 static ssize_t cifs_write(struct file *file, const char *write_data,
899 size_t write_size, loff_t *poffset)
900 {
901 int rc = 0;
902 unsigned int bytes_written = 0;
903 unsigned int total_written;
904 struct cifs_sb_info *cifs_sb;
905 struct cifsTconInfo *pTcon;
906 int xid, long_op;
907 struct cifsFileInfo *open_file;
908
909 if (file->f_dentry == NULL)
910 return -EBADF;
911
912 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
913 if (cifs_sb == NULL)
914 return -EBADF;
915
916 pTcon = cifs_sb->tcon;
917
918 cFYI(1,("write %zd bytes to offset %lld of %s", write_size,
919 *poffset, file->f_dentry->d_name.name));
920
921 if (file->private_data == NULL)
922 return -EBADF;
923 else
924 open_file = (struct cifsFileInfo *)file->private_data;
925
926 xid = GetXid();
927 if (file->f_dentry->d_inode == NULL) {
928 FreeXid(xid);
929 return -EBADF;
930 }
931
932 if (*poffset > file->f_dentry->d_inode->i_size)
933 long_op = 2; /* writes past end of file can take a long time */
934 else
935 long_op = 1;
936
937 for (total_written = 0; write_size > total_written;
938 total_written += bytes_written) {
939 rc = -EAGAIN;
940 while (rc == -EAGAIN) {
941 if (file->private_data == NULL) {
942 /* file has been closed on us */
943 FreeXid(xid);
944 /* if we have gotten here we have written some data
945 and blocked, and the file has been freed on us
946 while we blocked so return what we managed to
947 write */
948 return total_written;
949 }
950 if (open_file->closePend) {
951 FreeXid(xid);
952 if (total_written)
953 return total_written;
954 else
955 return -EBADF;
956 }
957 if (open_file->invalidHandle) {
958 if ((file->f_dentry == NULL) ||
959 (file->f_dentry->d_inode == NULL)) {
960 FreeXid(xid);
961 return total_written;
962 }
963 /* we could deadlock if we called
964 filemap_fdatawait from here so tell
965 reopen_file not to flush data to
966 server now */
967 rc = cifs_reopen_file(file->f_dentry->d_inode,
968 file, FALSE);
969 if (rc != 0)
970 break;
971 }
972 if(experimEnabled || (pTcon->ses->server &&
973 ((pTcon->ses->server->secMode &
974 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
975 == 0))) {
976 struct kvec iov[2];
977 unsigned int len;
978
979 len = min((size_t)cifs_sb->wsize,
980 write_size - total_written);
981 /* iov[0] is reserved for smb header */
982 iov[1].iov_base = (char *)write_data +
983 total_written;
984 iov[1].iov_len = len;
985 rc = CIFSSMBWrite2(xid, pTcon,
986 open_file->netfid, len,
987 *poffset, &bytes_written,
988 iov, 1, long_op);
989 } else
990 rc = CIFSSMBWrite(xid, pTcon,
991 open_file->netfid,
992 min_t(const int, cifs_sb->wsize,
993 write_size - total_written),
994 *poffset, &bytes_written,
995 write_data + total_written,
996 NULL, long_op);
997 }
998 if (rc || (bytes_written == 0)) {
999 if (total_written)
1000 break;
1001 else {
1002 FreeXid(xid);
1003 return rc;
1004 }
1005 } else
1006 *poffset += bytes_written;
1007 long_op = FALSE; /* subsequent writes fast -
1008 15 seconds is plenty */
1009 }
1010
1011 cifs_stats_bytes_written(pTcon, total_written);
1012
1013 /* since the write may have blocked check these pointers again */
1014 if (file->f_dentry) {
1015 if (file->f_dentry->d_inode) {
1016 file->f_dentry->d_inode->i_ctime =
1017 file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
1018 if (total_written > 0) {
1019 if (*poffset > file->f_dentry->d_inode->i_size)
1020 i_size_write(file->f_dentry->d_inode,
1021 *poffset);
1022 }
1023 mark_inode_dirty_sync(file->f_dentry->d_inode);
1024 }
1025 }
1026 FreeXid(xid);
1027 return total_written;
1028 }
1029
1030 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
1031 {
1032 struct cifsFileInfo *open_file;
1033 int rc;
1034
1035 /* Having a null inode here (because mapping->host was set to zero by
1036 the VFS or MM) should not happen but we had reports of on oops (due to
1037 it being zero) during stress testcases so we need to check for it */
1038
1039 if(cifs_inode == NULL) {
1040 cERROR(1,("Null inode passed to cifs_writeable_file"));
1041 dump_stack();
1042 return NULL;
1043 }
1044
1045 read_lock(&GlobalSMBSeslock);
1046 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1047 if (open_file->closePend)
1048 continue;
1049 if (open_file->pfile &&
1050 ((open_file->pfile->f_flags & O_RDWR) ||
1051 (open_file->pfile->f_flags & O_WRONLY))) {
1052 atomic_inc(&open_file->wrtPending);
1053 read_unlock(&GlobalSMBSeslock);
1054 if((open_file->invalidHandle) &&
1055 (!open_file->closePend) /* BB fixme -since the second clause can not be true remove it BB */) {
1056 rc = cifs_reopen_file(&cifs_inode->vfs_inode,
1057 open_file->pfile, FALSE);
1058 /* if it fails, try another handle - might be */
1059 /* dangerous to hold up writepages with retry */
1060 if(rc) {
1061 cFYI(1,("failed on reopen file in wp"));
1062 read_lock(&GlobalSMBSeslock);
1063 /* can not use this handle, no write
1064 pending on this one after all */
1065 atomic_dec
1066 (&open_file->wrtPending);
1067 continue;
1068 }
1069 }
1070 return open_file;
1071 }
1072 }
1073 read_unlock(&GlobalSMBSeslock);
1074 return NULL;
1075 }
1076
1077 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1078 {
1079 struct address_space *mapping = page->mapping;
1080 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1081 char *write_data;
1082 int rc = -EFAULT;
1083 int bytes_written = 0;
1084 struct cifs_sb_info *cifs_sb;
1085 struct cifsTconInfo *pTcon;
1086 struct inode *inode;
1087 struct cifsFileInfo *open_file;
1088
1089 if (!mapping || !mapping->host)
1090 return -EFAULT;
1091
1092 inode = page->mapping->host;
1093 cifs_sb = CIFS_SB(inode->i_sb);
1094 pTcon = cifs_sb->tcon;
1095
1096 offset += (loff_t)from;
1097 write_data = kmap(page);
1098 write_data += from;
1099
1100 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1101 kunmap(page);
1102 return -EIO;
1103 }
1104
1105 /* racing with truncate? */
1106 if (offset > mapping->host->i_size) {
1107 kunmap(page);
1108 return 0; /* don't care */
1109 }
1110
1111 /* check to make sure that we are not extending the file */
1112 if (mapping->host->i_size - offset < (loff_t)to)
1113 to = (unsigned)(mapping->host->i_size - offset);
1114
1115 open_file = find_writable_file(CIFS_I(mapping->host));
1116 if (open_file) {
1117 bytes_written = cifs_write(open_file->pfile, write_data,
1118 to-from, &offset);
1119 atomic_dec(&open_file->wrtPending);
1120 /* Does mm or vfs already set times? */
1121 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1122 if ((bytes_written > 0) && (offset)) {
1123 rc = 0;
1124 } else if (bytes_written < 0) {
1125 if (rc != -EBADF)
1126 rc = bytes_written;
1127 }
1128 } else {
1129 cFYI(1, ("No writeable filehandles for inode"));
1130 rc = -EIO;
1131 }
1132
1133 kunmap(page);
1134 return rc;
1135 }
1136
1137 static int cifs_writepages(struct address_space *mapping,
1138 struct writeback_control *wbc)
1139 {
1140 struct backing_dev_info *bdi = mapping->backing_dev_info;
1141 unsigned int bytes_to_write;
1142 unsigned int bytes_written;
1143 struct cifs_sb_info *cifs_sb;
1144 int done = 0;
1145 pgoff_t end;
1146 pgoff_t index;
1147 int range_whole = 0;
1148 struct kvec iov[32];
1149 int len;
1150 int n_iov = 0;
1151 pgoff_t next;
1152 int nr_pages;
1153 __u64 offset = 0;
1154 struct cifsFileInfo *open_file;
1155 struct page *page;
1156 struct pagevec pvec;
1157 int rc = 0;
1158 int scanned = 0;
1159 int xid;
1160
1161 cifs_sb = CIFS_SB(mapping->host->i_sb);
1162
1163 /*
1164 * If wsize is smaller that the page cache size, default to writing
1165 * one page at a time via cifs_writepage
1166 */
1167 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1168 return generic_writepages(mapping, wbc);
1169
1170 if((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1171 if(cifs_sb->tcon->ses->server->secMode &
1172 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1173 if(!experimEnabled)
1174 return generic_writepages(mapping, wbc);
1175
1176 /*
1177 * BB: Is this meaningful for a non-block-device file system?
1178 * If it is, we should test it again after we do I/O
1179 */
1180 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1181 wbc->encountered_congestion = 1;
1182 return 0;
1183 }
1184
1185 xid = GetXid();
1186
1187 pagevec_init(&pvec, 0);
1188 if (wbc->range_cyclic) {
1189 index = mapping->writeback_index; /* Start from prev offset */
1190 end = -1;
1191 } else {
1192 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1193 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1194 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1195 range_whole = 1;
1196 scanned = 1;
1197 }
1198 retry:
1199 while (!done && (index <= end) &&
1200 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1201 PAGECACHE_TAG_DIRTY,
1202 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1203 int first;
1204 unsigned int i;
1205
1206 first = -1;
1207 next = 0;
1208 n_iov = 0;
1209 bytes_to_write = 0;
1210
1211 for (i = 0; i < nr_pages; i++) {
1212 page = pvec.pages[i];
1213 /*
1214 * At this point we hold neither mapping->tree_lock nor
1215 * lock on the page itself: the page may be truncated or
1216 * invalidated (changing page->mapping to NULL), or even
1217 * swizzled back from swapper_space to tmpfs file
1218 * mapping
1219 */
1220
1221 if (first < 0)
1222 lock_page(page);
1223 else if (TestSetPageLocked(page))
1224 break;
1225
1226 if (unlikely(page->mapping != mapping)) {
1227 unlock_page(page);
1228 break;
1229 }
1230
1231 if (!wbc->range_cyclic && page->index > end) {
1232 done = 1;
1233 unlock_page(page);
1234 break;
1235 }
1236
1237 if (next && (page->index != next)) {
1238 /* Not next consecutive page */
1239 unlock_page(page);
1240 break;
1241 }
1242
1243 if (wbc->sync_mode != WB_SYNC_NONE)
1244 wait_on_page_writeback(page);
1245
1246 if (PageWriteback(page) ||
1247 !test_clear_page_dirty(page)) {
1248 unlock_page(page);
1249 break;
1250 }
1251
1252 if (page_offset(page) >= mapping->host->i_size) {
1253 done = 1;
1254 unlock_page(page);
1255 break;
1256 }
1257
1258 /*
1259 * BB can we get rid of this? pages are held by pvec
1260 */
1261 page_cache_get(page);
1262
1263 len = min(mapping->host->i_size - page_offset(page),
1264 (loff_t)PAGE_CACHE_SIZE);
1265
1266 /* reserve iov[0] for the smb header */
1267 n_iov++;
1268 iov[n_iov].iov_base = kmap(page);
1269 iov[n_iov].iov_len = len;
1270 bytes_to_write += len;
1271
1272 if (first < 0) {
1273 first = i;
1274 offset = page_offset(page);
1275 }
1276 next = page->index + 1;
1277 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1278 break;
1279 }
1280 if (n_iov) {
1281 /* Search for a writable handle every time we call
1282 * CIFSSMBWrite2. We can't rely on the last handle
1283 * we used to still be valid
1284 */
1285 open_file = find_writable_file(CIFS_I(mapping->host));
1286 if (!open_file) {
1287 cERROR(1, ("No writable handles for inode"));
1288 rc = -EBADF;
1289 } else {
1290 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1291 open_file->netfid,
1292 bytes_to_write, offset,
1293 &bytes_written, iov, n_iov,
1294 1);
1295 atomic_dec(&open_file->wrtPending);
1296 if (rc || bytes_written < bytes_to_write) {
1297 cERROR(1,("Write2 ret %d, written = %d",
1298 rc, bytes_written));
1299 /* BB what if continued retry is
1300 requested via mount flags? */
1301 set_bit(AS_EIO, &mapping->flags);
1302 } else {
1303 cifs_stats_bytes_written(cifs_sb->tcon,
1304 bytes_written);
1305 }
1306 }
1307 for (i = 0; i < n_iov; i++) {
1308 page = pvec.pages[first + i];
1309 /* Should we also set page error on
1310 success rc but too little data written? */
1311 /* BB investigate retry logic on temporary
1312 server crash cases and how recovery works
1313 when page marked as error */
1314 if(rc)
1315 SetPageError(page);
1316 kunmap(page);
1317 unlock_page(page);
1318 page_cache_release(page);
1319 }
1320 if ((wbc->nr_to_write -= n_iov) <= 0)
1321 done = 1;
1322 index = next;
1323 }
1324 pagevec_release(&pvec);
1325 }
1326 if (!scanned && !done) {
1327 /*
1328 * We hit the last page and there is more work to be done: wrap
1329 * back to the start of the file
1330 */
1331 scanned = 1;
1332 index = 0;
1333 goto retry;
1334 }
1335 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1336 mapping->writeback_index = index;
1337
1338 FreeXid(xid);
1339
1340 return rc;
1341 }
1342
1343 static int cifs_writepage(struct page* page, struct writeback_control *wbc)
1344 {
1345 int rc = -EFAULT;
1346 int xid;
1347
1348 xid = GetXid();
1349 /* BB add check for wbc flags */
1350 page_cache_get(page);
1351 if (!PageUptodate(page)) {
1352 cFYI(1, ("ppw - page not up to date"));
1353 }
1354
1355 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1356 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1357 unlock_page(page);
1358 page_cache_release(page);
1359 FreeXid(xid);
1360 return rc;
1361 }
1362
1363 static int cifs_commit_write(struct file *file, struct page *page,
1364 unsigned offset, unsigned to)
1365 {
1366 int xid;
1367 int rc = 0;
1368 struct inode *inode = page->mapping->host;
1369 loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1370 char *page_data;
1371
1372 xid = GetXid();
1373 cFYI(1, ("commit write for page %p up to position %lld for %d",
1374 page, position, to));
1375 if (position > inode->i_size) {
1376 i_size_write(inode, position);
1377 /* if (file->private_data == NULL) {
1378 rc = -EBADF;
1379 } else {
1380 open_file = (struct cifsFileInfo *)file->private_data;
1381 cifs_sb = CIFS_SB(inode->i_sb);
1382 rc = -EAGAIN;
1383 while (rc == -EAGAIN) {
1384 if ((open_file->invalidHandle) &&
1385 (!open_file->closePend)) {
1386 rc = cifs_reopen_file(
1387 file->f_dentry->d_inode, file);
1388 if (rc != 0)
1389 break;
1390 }
1391 if (!open_file->closePend) {
1392 rc = CIFSSMBSetFileSize(xid,
1393 cifs_sb->tcon, position,
1394 open_file->netfid,
1395 open_file->pid, FALSE);
1396 } else {
1397 rc = -EBADF;
1398 break;
1399 }
1400 }
1401 cFYI(1, (" SetEOF (commit write) rc = %d", rc));
1402 } */
1403 }
1404 if (!PageUptodate(page)) {
1405 position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1406 /* can not rely on (or let) writepage write this data */
1407 if (to < offset) {
1408 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1409 offset, to));
1410 FreeXid(xid);
1411 return rc;
1412 }
1413 /* this is probably better than directly calling
1414 partialpage_write since in this function the file handle is
1415 known which we might as well leverage */
1416 /* BB check if anything else missing out of ppw
1417 such as updating last write time */
1418 page_data = kmap(page);
1419 rc = cifs_write(file, page_data + offset, to-offset,
1420 &position);
1421 if (rc > 0)
1422 rc = 0;
1423 /* else if (rc < 0) should we set writebehind rc? */
1424 kunmap(page);
1425 } else {
1426 set_page_dirty(page);
1427 }
1428
1429 FreeXid(xid);
1430 return rc;
1431 }
1432
1433 int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1434 {
1435 int xid;
1436 int rc = 0;
1437 struct inode *inode = file->f_dentry->d_inode;
1438
1439 xid = GetXid();
1440
1441 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
1442 dentry->d_name.name, datasync));
1443
1444 rc = filemap_fdatawrite(inode->i_mapping);
1445 if (rc == 0)
1446 CIFS_I(inode)->write_behind_rc = 0;
1447 FreeXid(xid);
1448 return rc;
1449 }
1450
1451 /* static void cifs_sync_page(struct page *page)
1452 {
1453 struct address_space *mapping;
1454 struct inode *inode;
1455 unsigned long index = page->index;
1456 unsigned int rpages = 0;
1457 int rc = 0;
1458
1459 cFYI(1, ("sync page %p",page));
1460 mapping = page->mapping;
1461 if (!mapping)
1462 return 0;
1463 inode = mapping->host;
1464 if (!inode)
1465 return; */
1466
1467 /* fill in rpages then
1468 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1469
1470 /* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
1471
1472 #if 0
1473 if (rc < 0)
1474 return rc;
1475 return 0;
1476 #endif
1477 } */
1478
1479 /*
1480 * As file closes, flush all cached write data for this inode checking
1481 * for write behind errors.
1482 */
1483 int cifs_flush(struct file *file, fl_owner_t id)
1484 {
1485 struct inode * inode = file->f_dentry->d_inode;
1486 int rc = 0;
1487
1488 /* Rather than do the steps manually:
1489 lock the inode for writing
1490 loop through pages looking for write behind data (dirty pages)
1491 coalesce into contiguous 16K (or smaller) chunks to write to server
1492 send to server (prefer in parallel)
1493 deal with writebehind errors
1494 unlock inode for writing
1495 filemapfdatawrite appears easier for the time being */
1496
1497 rc = filemap_fdatawrite(inode->i_mapping);
1498 if (!rc) /* reset wb rc if we were able to write out dirty pages */
1499 CIFS_I(inode)->write_behind_rc = 0;
1500
1501 cFYI(1, ("Flush inode %p file %p rc %d",inode,file,rc));
1502
1503 return rc;
1504 }
1505
1506 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1507 size_t read_size, loff_t *poffset)
1508 {
1509 int rc = -EACCES;
1510 unsigned int bytes_read = 0;
1511 unsigned int total_read = 0;
1512 unsigned int current_read_size;
1513 struct cifs_sb_info *cifs_sb;
1514 struct cifsTconInfo *pTcon;
1515 int xid;
1516 struct cifsFileInfo *open_file;
1517 char *smb_read_data;
1518 char __user *current_offset;
1519 struct smb_com_read_rsp *pSMBr;
1520
1521 xid = GetXid();
1522 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1523 pTcon = cifs_sb->tcon;
1524
1525 if (file->private_data == NULL) {
1526 FreeXid(xid);
1527 return -EBADF;
1528 }
1529 open_file = (struct cifsFileInfo *)file->private_data;
1530
1531 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
1532 cFYI(1, ("attempting read on write only file instance"));
1533 }
1534 for (total_read = 0, current_offset = read_data;
1535 read_size > total_read;
1536 total_read += bytes_read, current_offset += bytes_read) {
1537 current_read_size = min_t(const int, read_size - total_read,
1538 cifs_sb->rsize);
1539 rc = -EAGAIN;
1540 smb_read_data = NULL;
1541 while (rc == -EAGAIN) {
1542 int buf_type = CIFS_NO_BUFFER;
1543 if ((open_file->invalidHandle) &&
1544 (!open_file->closePend)) {
1545 rc = cifs_reopen_file(file->f_dentry->d_inode,
1546 file, TRUE);
1547 if (rc != 0)
1548 break;
1549 }
1550 rc = CIFSSMBRead(xid, pTcon,
1551 open_file->netfid,
1552 current_read_size, *poffset,
1553 &bytes_read, &smb_read_data,
1554 &buf_type);
1555 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1556 if (smb_read_data) {
1557 if (copy_to_user(current_offset,
1558 smb_read_data +
1559 4 /* RFC1001 length field */ +
1560 le16_to_cpu(pSMBr->DataOffset),
1561 bytes_read)) {
1562 rc = -EFAULT;
1563 }
1564
1565 if(buf_type == CIFS_SMALL_BUFFER)
1566 cifs_small_buf_release(smb_read_data);
1567 else if(buf_type == CIFS_LARGE_BUFFER)
1568 cifs_buf_release(smb_read_data);
1569 smb_read_data = NULL;
1570 }
1571 }
1572 if (rc || (bytes_read == 0)) {
1573 if (total_read) {
1574 break;
1575 } else {
1576 FreeXid(xid);
1577 return rc;
1578 }
1579 } else {
1580 cifs_stats_bytes_read(pTcon, bytes_read);
1581 *poffset += bytes_read;
1582 }
1583 }
1584 FreeXid(xid);
1585 return total_read;
1586 }
1587
1588
1589 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1590 loff_t *poffset)
1591 {
1592 int rc = -EACCES;
1593 unsigned int bytes_read = 0;
1594 unsigned int total_read;
1595 unsigned int current_read_size;
1596 struct cifs_sb_info *cifs_sb;
1597 struct cifsTconInfo *pTcon;
1598 int xid;
1599 char *current_offset;
1600 struct cifsFileInfo *open_file;
1601 int buf_type = CIFS_NO_BUFFER;
1602
1603 xid = GetXid();
1604 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1605 pTcon = cifs_sb->tcon;
1606
1607 if (file->private_data == NULL) {
1608 FreeXid(xid);
1609 return -EBADF;
1610 }
1611 open_file = (struct cifsFileInfo *)file->private_data;
1612
1613 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1614 cFYI(1, ("attempting read on write only file instance"));
1615
1616 for (total_read = 0, current_offset = read_data;
1617 read_size > total_read;
1618 total_read += bytes_read, current_offset += bytes_read) {
1619 current_read_size = min_t(const int, read_size - total_read,
1620 cifs_sb->rsize);
1621 /* For windows me and 9x we do not want to request more
1622 than it negotiated since it will refuse the read then */
1623 if((pTcon->ses) &&
1624 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1625 current_read_size = min_t(const int, current_read_size,
1626 pTcon->ses->server->maxBuf - 128);
1627 }
1628 rc = -EAGAIN;
1629 while (rc == -EAGAIN) {
1630 if ((open_file->invalidHandle) &&
1631 (!open_file->closePend)) {
1632 rc = cifs_reopen_file(file->f_dentry->d_inode,
1633 file, TRUE);
1634 if (rc != 0)
1635 break;
1636 }
1637 rc = CIFSSMBRead(xid, pTcon,
1638 open_file->netfid,
1639 current_read_size, *poffset,
1640 &bytes_read, &current_offset,
1641 &buf_type);
1642 }
1643 if (rc || (bytes_read == 0)) {
1644 if (total_read) {
1645 break;
1646 } else {
1647 FreeXid(xid);
1648 return rc;
1649 }
1650 } else {
1651 cifs_stats_bytes_read(pTcon, total_read);
1652 *poffset += bytes_read;
1653 }
1654 }
1655 FreeXid(xid);
1656 return total_read;
1657 }
1658
1659 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1660 {
1661 struct dentry *dentry = file->f_dentry;
1662 int rc, xid;
1663
1664 xid = GetXid();
1665 rc = cifs_revalidate(dentry);
1666 if (rc) {
1667 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1668 FreeXid(xid);
1669 return rc;
1670 }
1671 rc = generic_file_mmap(file, vma);
1672 FreeXid(xid);
1673 return rc;
1674 }
1675
1676
1677 static void cifs_copy_cache_pages(struct address_space *mapping,
1678 struct list_head *pages, int bytes_read, char *data,
1679 struct pagevec *plru_pvec)
1680 {
1681 struct page *page;
1682 char *target;
1683
1684 while (bytes_read > 0) {
1685 if (list_empty(pages))
1686 break;
1687
1688 page = list_entry(pages->prev, struct page, lru);
1689 list_del(&page->lru);
1690
1691 if (add_to_page_cache(page, mapping, page->index,
1692 GFP_KERNEL)) {
1693 page_cache_release(page);
1694 cFYI(1, ("Add page cache failed"));
1695 data += PAGE_CACHE_SIZE;
1696 bytes_read -= PAGE_CACHE_SIZE;
1697 continue;
1698 }
1699
1700 target = kmap_atomic(page,KM_USER0);
1701
1702 if (PAGE_CACHE_SIZE > bytes_read) {
1703 memcpy(target, data, bytes_read);
1704 /* zero the tail end of this partial page */
1705 memset(target + bytes_read, 0,
1706 PAGE_CACHE_SIZE - bytes_read);
1707 bytes_read = 0;
1708 } else {
1709 memcpy(target, data, PAGE_CACHE_SIZE);
1710 bytes_read -= PAGE_CACHE_SIZE;
1711 }
1712 kunmap_atomic(target, KM_USER0);
1713
1714 flush_dcache_page(page);
1715 SetPageUptodate(page);
1716 unlock_page(page);
1717 if (!pagevec_add(plru_pvec, page))
1718 __pagevec_lru_add(plru_pvec);
1719 data += PAGE_CACHE_SIZE;
1720 }
1721 return;
1722 }
1723
1724 static int cifs_readpages(struct file *file, struct address_space *mapping,
1725 struct list_head *page_list, unsigned num_pages)
1726 {
1727 int rc = -EACCES;
1728 int xid;
1729 loff_t offset;
1730 struct page *page;
1731 struct cifs_sb_info *cifs_sb;
1732 struct cifsTconInfo *pTcon;
1733 int bytes_read = 0;
1734 unsigned int read_size,i;
1735 char *smb_read_data = NULL;
1736 struct smb_com_read_rsp *pSMBr;
1737 struct pagevec lru_pvec;
1738 struct cifsFileInfo *open_file;
1739 int buf_type = CIFS_NO_BUFFER;
1740
1741 xid = GetXid();
1742 if (file->private_data == NULL) {
1743 FreeXid(xid);
1744 return -EBADF;
1745 }
1746 open_file = (struct cifsFileInfo *)file->private_data;
1747 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1748 pTcon = cifs_sb->tcon;
1749
1750 pagevec_init(&lru_pvec, 0);
1751
1752 for (i = 0; i < num_pages; ) {
1753 unsigned contig_pages;
1754 struct page *tmp_page;
1755 unsigned long expected_index;
1756
1757 if (list_empty(page_list))
1758 break;
1759
1760 page = list_entry(page_list->prev, struct page, lru);
1761 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1762
1763 /* count adjacent pages that we will read into */
1764 contig_pages = 0;
1765 expected_index =
1766 list_entry(page_list->prev, struct page, lru)->index;
1767 list_for_each_entry_reverse(tmp_page,page_list,lru) {
1768 if (tmp_page->index == expected_index) {
1769 contig_pages++;
1770 expected_index++;
1771 } else
1772 break;
1773 }
1774 if (contig_pages + i > num_pages)
1775 contig_pages = num_pages - i;
1776
1777 /* for reads over a certain size could initiate async
1778 read ahead */
1779
1780 read_size = contig_pages * PAGE_CACHE_SIZE;
1781 /* Read size needs to be in multiples of one page */
1782 read_size = min_t(const unsigned int, read_size,
1783 cifs_sb->rsize & PAGE_CACHE_MASK);
1784
1785 rc = -EAGAIN;
1786 while (rc == -EAGAIN) {
1787 if ((open_file->invalidHandle) &&
1788 (!open_file->closePend)) {
1789 rc = cifs_reopen_file(file->f_dentry->d_inode,
1790 file, TRUE);
1791 if (rc != 0)
1792 break;
1793 }
1794
1795 rc = CIFSSMBRead(xid, pTcon,
1796 open_file->netfid,
1797 read_size, offset,
1798 &bytes_read, &smb_read_data,
1799 &buf_type);
1800 /* BB more RC checks ? */
1801 if (rc== -EAGAIN) {
1802 if (smb_read_data) {
1803 if(buf_type == CIFS_SMALL_BUFFER)
1804 cifs_small_buf_release(smb_read_data);
1805 else if(buf_type == CIFS_LARGE_BUFFER)
1806 cifs_buf_release(smb_read_data);
1807 smb_read_data = NULL;
1808 }
1809 }
1810 }
1811 if ((rc < 0) || (smb_read_data == NULL)) {
1812 cFYI(1, ("Read error in readpages: %d", rc));
1813 break;
1814 } else if (bytes_read > 0) {
1815 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1816 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1817 smb_read_data + 4 /* RFC1001 hdr */ +
1818 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1819
1820 i += bytes_read >> PAGE_CACHE_SHIFT;
1821 cifs_stats_bytes_read(pTcon, bytes_read);
1822 if ((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1823 i++; /* account for partial page */
1824
1825 /* server copy of file can have smaller size
1826 than client */
1827 /* BB do we need to verify this common case ?
1828 this case is ok - if we are at server EOF
1829 we will hit it on next read */
1830
1831 /* break; */
1832 }
1833 } else {
1834 cFYI(1, ("No bytes read (%d) at offset %lld . "
1835 "Cleaning remaining pages from readahead list",
1836 bytes_read, offset));
1837 /* BB turn off caching and do new lookup on
1838 file size at server? */
1839 break;
1840 }
1841 if (smb_read_data) {
1842 if(buf_type == CIFS_SMALL_BUFFER)
1843 cifs_small_buf_release(smb_read_data);
1844 else if(buf_type == CIFS_LARGE_BUFFER)
1845 cifs_buf_release(smb_read_data);
1846 smb_read_data = NULL;
1847 }
1848 bytes_read = 0;
1849 }
1850
1851 pagevec_lru_add(&lru_pvec);
1852
1853 /* need to free smb_read_data buf before exit */
1854 if (smb_read_data) {
1855 if(buf_type == CIFS_SMALL_BUFFER)
1856 cifs_small_buf_release(smb_read_data);
1857 else if(buf_type == CIFS_LARGE_BUFFER)
1858 cifs_buf_release(smb_read_data);
1859 smb_read_data = NULL;
1860 }
1861
1862 FreeXid(xid);
1863 return rc;
1864 }
1865
1866 static int cifs_readpage_worker(struct file *file, struct page *page,
1867 loff_t *poffset)
1868 {
1869 char *read_data;
1870 int rc;
1871
1872 page_cache_get(page);
1873 read_data = kmap(page);
1874 /* for reads over a certain size could initiate async read ahead */
1875
1876 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
1877
1878 if (rc < 0)
1879 goto io_error;
1880 else
1881 cFYI(1, ("Bytes read %d",rc));
1882
1883 file->f_dentry->d_inode->i_atime =
1884 current_fs_time(file->f_dentry->d_inode->i_sb);
1885
1886 if (PAGE_CACHE_SIZE > rc)
1887 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1888
1889 flush_dcache_page(page);
1890 SetPageUptodate(page);
1891 rc = 0;
1892
1893 io_error:
1894 kunmap(page);
1895 page_cache_release(page);
1896 return rc;
1897 }
1898
1899 static int cifs_readpage(struct file *file, struct page *page)
1900 {
1901 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1902 int rc = -EACCES;
1903 int xid;
1904
1905 xid = GetXid();
1906
1907 if (file->private_data == NULL) {
1908 FreeXid(xid);
1909 return -EBADF;
1910 }
1911
1912 cFYI(1, ("readpage %p at offset %d 0x%x\n",
1913 page, (int)offset, (int)offset));
1914
1915 rc = cifs_readpage_worker(file, page, &offset);
1916
1917 unlock_page(page);
1918
1919 FreeXid(xid);
1920 return rc;
1921 }
1922
1923 /* We do not want to update the file size from server for inodes
1924 open for write - to avoid races with writepage extending
1925 the file - in the future we could consider allowing
1926 refreshing the inode only on increases in the file size
1927 but this is tricky to do without racing with writebehind
1928 page caching in the current Linux kernel design */
1929 int is_size_safe_to_change(struct cifsInodeInfo *cifsInode)
1930 {
1931 struct cifsFileInfo *open_file = NULL;
1932
1933 if (cifsInode)
1934 open_file = find_writable_file(cifsInode);
1935
1936 if(open_file) {
1937 struct cifs_sb_info *cifs_sb;
1938
1939 /* there is not actually a write pending so let
1940 this handle go free and allow it to
1941 be closable if needed */
1942 atomic_dec(&open_file->wrtPending);
1943
1944 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
1945 if ( cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO ) {
1946 /* since no page cache to corrupt on directio
1947 we can change size safely */
1948 return 1;
1949 }
1950
1951 return 0;
1952 } else
1953 return 1;
1954 }
1955
1956 static int cifs_prepare_write(struct file *file, struct page *page,
1957 unsigned from, unsigned to)
1958 {
1959 int rc = 0;
1960 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1961 cFYI(1, ("prepare write for page %p from %d to %d",page,from,to));
1962 if (!PageUptodate(page)) {
1963 /* if (to - from != PAGE_CACHE_SIZE) {
1964 void *kaddr = kmap_atomic(page, KM_USER0);
1965 memset(kaddr, 0, from);
1966 memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
1967 flush_dcache_page(page);
1968 kunmap_atomic(kaddr, KM_USER0);
1969 } */
1970 /* If we are writing a full page it will be up to date,
1971 no need to read from the server */
1972 if ((to == PAGE_CACHE_SIZE) && (from == 0))
1973 SetPageUptodate(page);
1974
1975 /* might as well read a page, it is fast enough */
1976 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
1977 rc = cifs_readpage_worker(file, page, &offset);
1978 } else {
1979 /* should we try using another file handle if there is one -
1980 how would we lock it to prevent close of that handle
1981 racing with this read?
1982 In any case this will be written out by commit_write */
1983 }
1984 }
1985
1986 /* BB should we pass any errors back?
1987 e.g. if we do not have read access to the file */
1988 return 0;
1989 }
1990
1991 const struct address_space_operations cifs_addr_ops = {
1992 .readpage = cifs_readpage,
1993 .readpages = cifs_readpages,
1994 .writepage = cifs_writepage,
1995 .writepages = cifs_writepages,
1996 .prepare_write = cifs_prepare_write,
1997 .commit_write = cifs_commit_write,
1998 .set_page_dirty = __set_page_dirty_nobuffers,
1999 /* .sync_page = cifs_sync_page, */
2000 /* .direct_IO = */
2001 };
2002
2003 /*
2004 * cifs_readpages requires the server to support a buffer large enough to
2005 * contain the header plus one complete page of data. Otherwise, we need
2006 * to leave cifs_readpages out of the address space operations.
2007 */
2008 const struct address_space_operations cifs_addr_ops_smallbuf = {
2009 .readpage = cifs_readpage,
2010 .writepage = cifs_writepage,
2011 .writepages = cifs_writepages,
2012 .prepare_write = cifs_prepare_write,
2013 .commit_write = cifs_commit_write,
2014 .set_page_dirty = __set_page_dirty_nobuffers,
2015 /* .sync_page = cifs_sync_page, */
2016 /* .direct_IO = */
2017 };
x86 "subsystem" repository