Linux 2.6.35-rc2
[linux/fpc-iii.git] / fs / cifs / file.c
blob75541af4b3db1395ecfab6fd318144b88b959fd8
1 /*
2 * fs/cifs/file.c
4 * vfs operations that deal with files
6 * Copyright (C) International Business Machines Corp., 2002,2010
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 * Jeremy Allison (jra@samba.org)
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.
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.
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
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/writeback.h>
31 #include <linux/task_io_accounting_ops.h>
32 #include <linux/delay.h>
33 #include <linux/mount.h>
34 #include <linux/slab.h>
35 #include <asm/div64.h>
36 #include "cifsfs.h"
37 #include "cifspdu.h"
38 #include "cifsglob.h"
39 #include "cifsproto.h"
40 #include "cifs_unicode.h"
41 #include "cifs_debug.h"
42 #include "cifs_fs_sb.h"
44 static inline int cifs_convert_flags(unsigned int flags)
46 if ((flags & O_ACCMODE) == O_RDONLY)
47 return GENERIC_READ;
48 else if ((flags & O_ACCMODE) == O_WRONLY)
49 return GENERIC_WRITE;
50 else if ((flags & O_ACCMODE) == O_RDWR) {
51 /* GENERIC_ALL is too much permission to request
52 can cause unnecessary access denied on create */
53 /* return GENERIC_ALL; */
54 return (GENERIC_READ | GENERIC_WRITE);
57 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
58 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
59 FILE_READ_DATA);
62 static inline fmode_t cifs_posix_convert_flags(unsigned int flags)
64 fmode_t posix_flags = 0;
66 if ((flags & O_ACCMODE) == O_RDONLY)
67 posix_flags = FMODE_READ;
68 else if ((flags & O_ACCMODE) == O_WRONLY)
69 posix_flags = FMODE_WRITE;
70 else if ((flags & O_ACCMODE) == O_RDWR) {
71 /* GENERIC_ALL is too much permission to request
72 can cause unnecessary access denied on create */
73 /* return GENERIC_ALL; */
74 posix_flags = FMODE_READ | FMODE_WRITE;
76 /* can not map O_CREAT or O_EXCL or O_TRUNC flags when
77 reopening a file. They had their effect on the original open */
78 if (flags & O_APPEND)
79 posix_flags |= (fmode_t)O_APPEND;
80 if (flags & O_DSYNC)
81 posix_flags |= (fmode_t)O_DSYNC;
82 if (flags & __O_SYNC)
83 posix_flags |= (fmode_t)__O_SYNC;
84 if (flags & O_DIRECTORY)
85 posix_flags |= (fmode_t)O_DIRECTORY;
86 if (flags & O_NOFOLLOW)
87 posix_flags |= (fmode_t)O_NOFOLLOW;
88 if (flags & O_DIRECT)
89 posix_flags |= (fmode_t)O_DIRECT;
91 return posix_flags;
94 static inline int cifs_get_disposition(unsigned int flags)
96 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
97 return FILE_CREATE;
98 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
99 return FILE_OVERWRITE_IF;
100 else if ((flags & O_CREAT) == O_CREAT)
101 return FILE_OPEN_IF;
102 else if ((flags & O_TRUNC) == O_TRUNC)
103 return FILE_OVERWRITE;
104 else
105 return FILE_OPEN;
108 /* all arguments to this function must be checked for validity in caller */
109 static inline int
110 cifs_posix_open_inode_helper(struct inode *inode, struct file *file,
111 struct cifsInodeInfo *pCifsInode, __u32 oplock,
112 u16 netfid)
115 write_lock(&GlobalSMBSeslock);
117 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
118 if (pCifsInode == NULL) {
119 write_unlock(&GlobalSMBSeslock);
120 return -EINVAL;
123 if (pCifsInode->clientCanCacheRead) {
124 /* we have the inode open somewhere else
125 no need to discard cache data */
126 goto psx_client_can_cache;
129 /* BB FIXME need to fix this check to move it earlier into posix_open
130 BB fIX following section BB FIXME */
132 /* if not oplocked, invalidate inode pages if mtime or file
133 size changed */
134 /* temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
135 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
136 (file->f_path.dentry->d_inode->i_size ==
137 (loff_t)le64_to_cpu(buf->EndOfFile))) {
138 cFYI(1, "inode unchanged on server");
139 } else {
140 if (file->f_path.dentry->d_inode->i_mapping) {
141 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
142 if (rc != 0)
143 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
145 cFYI(1, "invalidating remote inode since open detected it "
146 "changed");
147 invalidate_remote_inode(file->f_path.dentry->d_inode);
148 } */
150 psx_client_can_cache:
151 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
152 pCifsInode->clientCanCacheAll = true;
153 pCifsInode->clientCanCacheRead = true;
154 cFYI(1, "Exclusive Oplock granted on inode %p",
155 file->f_path.dentry->d_inode);
156 } else if ((oplock & 0xF) == OPLOCK_READ)
157 pCifsInode->clientCanCacheRead = true;
159 /* will have to change the unlock if we reenable the
160 filemap_fdatawrite (which does not seem necessary */
161 write_unlock(&GlobalSMBSeslock);
162 return 0;
165 static struct cifsFileInfo *
166 cifs_fill_filedata(struct file *file)
168 struct list_head *tmp;
169 struct cifsFileInfo *pCifsFile = NULL;
170 struct cifsInodeInfo *pCifsInode = NULL;
172 /* search inode for this file and fill in file->private_data */
173 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
174 read_lock(&GlobalSMBSeslock);
175 list_for_each(tmp, &pCifsInode->openFileList) {
176 pCifsFile = list_entry(tmp, struct cifsFileInfo, flist);
177 if ((pCifsFile->pfile == NULL) &&
178 (pCifsFile->pid == current->tgid)) {
179 /* mode set in cifs_create */
181 /* needed for writepage */
182 pCifsFile->pfile = file;
183 file->private_data = pCifsFile;
184 break;
187 read_unlock(&GlobalSMBSeslock);
189 if (file->private_data != NULL) {
190 return pCifsFile;
191 } else if ((file->f_flags & O_CREAT) && (file->f_flags & O_EXCL))
192 cERROR(1, "could not find file instance for "
193 "new file %p", file);
194 return NULL;
197 /* all arguments to this function must be checked for validity in caller */
198 static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
199 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
200 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
201 char *full_path, int xid)
203 struct timespec temp;
204 int rc;
206 if (pCifsInode->clientCanCacheRead) {
207 /* we have the inode open somewhere else
208 no need to discard cache data */
209 goto client_can_cache;
212 /* BB need same check in cifs_create too? */
213 /* if not oplocked, invalidate inode pages if mtime or file
214 size changed */
215 temp = cifs_NTtimeToUnix(buf->LastWriteTime);
216 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
217 (file->f_path.dentry->d_inode->i_size ==
218 (loff_t)le64_to_cpu(buf->EndOfFile))) {
219 cFYI(1, "inode unchanged on server");
220 } else {
221 if (file->f_path.dentry->d_inode->i_mapping) {
222 /* BB no need to lock inode until after invalidate
223 since namei code should already have it locked? */
224 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
225 if (rc != 0)
226 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
228 cFYI(1, "invalidating remote inode since open detected it "
229 "changed");
230 invalidate_remote_inode(file->f_path.dentry->d_inode);
233 client_can_cache:
234 if (pTcon->unix_ext)
235 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
236 full_path, inode->i_sb, xid);
237 else
238 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
239 full_path, buf, inode->i_sb, xid, NULL);
241 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
242 pCifsInode->clientCanCacheAll = true;
243 pCifsInode->clientCanCacheRead = true;
244 cFYI(1, "Exclusive Oplock granted on inode %p",
245 file->f_path.dentry->d_inode);
246 } else if ((*oplock & 0xF) == OPLOCK_READ)
247 pCifsInode->clientCanCacheRead = true;
249 return rc;
252 int cifs_open(struct inode *inode, struct file *file)
254 int rc = -EACCES;
255 int xid;
256 __u32 oplock;
257 struct cifs_sb_info *cifs_sb;
258 struct cifsTconInfo *tcon;
259 struct cifsFileInfo *pCifsFile;
260 struct cifsInodeInfo *pCifsInode;
261 char *full_path = NULL;
262 int desiredAccess;
263 int disposition;
264 __u16 netfid;
265 FILE_ALL_INFO *buf = NULL;
267 xid = GetXid();
269 cifs_sb = CIFS_SB(inode->i_sb);
270 tcon = cifs_sb->tcon;
272 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
273 pCifsFile = cifs_fill_filedata(file);
274 if (pCifsFile) {
275 rc = 0;
276 FreeXid(xid);
277 return rc;
280 full_path = build_path_from_dentry(file->f_path.dentry);
281 if (full_path == NULL) {
282 rc = -ENOMEM;
283 FreeXid(xid);
284 return rc;
287 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
288 inode, file->f_flags, full_path);
290 if (oplockEnabled)
291 oplock = REQ_OPLOCK;
292 else
293 oplock = 0;
295 if (!tcon->broken_posix_open && tcon->unix_ext &&
296 (tcon->ses->capabilities & CAP_UNIX) &&
297 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
298 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
299 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
300 oflags |= SMB_O_CREAT;
301 /* can not refresh inode info since size could be stale */
302 rc = cifs_posix_open(full_path, &inode, file->f_path.mnt,
303 inode->i_sb,
304 cifs_sb->mnt_file_mode /* ignored */,
305 oflags, &oplock, &netfid, xid);
306 if (rc == 0) {
307 cFYI(1, "posix open succeeded");
308 /* no need for special case handling of setting mode
309 on read only files needed here */
311 pCifsFile = cifs_fill_filedata(file);
312 cifs_posix_open_inode_helper(inode, file, pCifsInode,
313 oplock, netfid);
314 goto out;
315 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
316 if (tcon->ses->serverNOS)
317 cERROR(1, "server %s of type %s returned"
318 " unexpected error on SMB posix open"
319 ", disabling posix open support."
320 " Check if server update available.",
321 tcon->ses->serverName,
322 tcon->ses->serverNOS);
323 tcon->broken_posix_open = true;
324 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
325 (rc != -EOPNOTSUPP)) /* path not found or net err */
326 goto out;
327 /* else fallthrough to retry open the old way on network i/o
328 or DFS errors */
331 desiredAccess = cifs_convert_flags(file->f_flags);
333 /*********************************************************************
334 * open flag mapping table:
336 * POSIX Flag CIFS Disposition
337 * ---------- ----------------
338 * O_CREAT FILE_OPEN_IF
339 * O_CREAT | O_EXCL FILE_CREATE
340 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
341 * O_TRUNC FILE_OVERWRITE
342 * none of the above FILE_OPEN
344 * Note that there is not a direct match between disposition
345 * FILE_SUPERSEDE (ie create whether or not file exists although
346 * O_CREAT | O_TRUNC is similar but truncates the existing
347 * file rather than creating a new file as FILE_SUPERSEDE does
348 * (which uses the attributes / metadata passed in on open call)
350 *? O_SYNC is a reasonable match to CIFS writethrough flag
351 *? and the read write flags match reasonably. O_LARGEFILE
352 *? is irrelevant because largefile support is always used
353 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
354 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
355 *********************************************************************/
357 disposition = cifs_get_disposition(file->f_flags);
359 /* BB pass O_SYNC flag through on file attributes .. BB */
361 /* Also refresh inode by passing in file_info buf returned by SMBOpen
362 and calling get_inode_info with returned buf (at least helps
363 non-Unix server case) */
365 /* BB we can not do this if this is the second open of a file
366 and the first handle has writebehind data, we might be
367 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
368 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
369 if (!buf) {
370 rc = -ENOMEM;
371 goto out;
374 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
375 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
376 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
377 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
378 & CIFS_MOUNT_MAP_SPECIAL_CHR);
379 else
380 rc = -EIO; /* no NT SMB support fall into legacy open below */
382 if (rc == -EIO) {
383 /* Old server, try legacy style OpenX */
384 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
385 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
386 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
387 & CIFS_MOUNT_MAP_SPECIAL_CHR);
389 if (rc) {
390 cFYI(1, "cifs_open returned 0x%x", rc);
391 goto out;
394 pCifsFile = cifs_new_fileinfo(inode, netfid, file, file->f_path.mnt,
395 file->f_flags);
396 file->private_data = pCifsFile;
397 if (file->private_data == NULL) {
398 rc = -ENOMEM;
399 goto out;
402 rc = cifs_open_inode_helper(inode, file, pCifsInode, pCifsFile, tcon,
403 &oplock, buf, full_path, xid);
405 if (oplock & CIFS_CREATE_ACTION) {
406 /* time to set mode which we can not set earlier due to
407 problems creating new read-only files */
408 if (tcon->unix_ext) {
409 struct cifs_unix_set_info_args args = {
410 .mode = inode->i_mode,
411 .uid = NO_CHANGE_64,
412 .gid = NO_CHANGE_64,
413 .ctime = NO_CHANGE_64,
414 .atime = NO_CHANGE_64,
415 .mtime = NO_CHANGE_64,
416 .device = 0,
418 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
419 cifs_sb->local_nls,
420 cifs_sb->mnt_cifs_flags &
421 CIFS_MOUNT_MAP_SPECIAL_CHR);
425 out:
426 kfree(buf);
427 kfree(full_path);
428 FreeXid(xid);
429 return rc;
432 /* Try to reacquire byte range locks that were released when session */
433 /* to server was lost */
434 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
436 int rc = 0;
438 /* BB list all locks open on this file and relock */
440 return rc;
443 static int cifs_reopen_file(struct file *file, bool can_flush)
445 int rc = -EACCES;
446 int xid;
447 __u32 oplock;
448 struct cifs_sb_info *cifs_sb;
449 struct cifsTconInfo *tcon;
450 struct cifsFileInfo *pCifsFile;
451 struct cifsInodeInfo *pCifsInode;
452 struct inode *inode;
453 char *full_path = NULL;
454 int desiredAccess;
455 int disposition = FILE_OPEN;
456 __u16 netfid;
458 if (file->private_data)
459 pCifsFile = (struct cifsFileInfo *)file->private_data;
460 else
461 return -EBADF;
463 xid = GetXid();
464 mutex_lock(&pCifsFile->fh_mutex);
465 if (!pCifsFile->invalidHandle) {
466 mutex_unlock(&pCifsFile->fh_mutex);
467 rc = 0;
468 FreeXid(xid);
469 return rc;
472 if (file->f_path.dentry == NULL) {
473 cERROR(1, "no valid name if dentry freed");
474 dump_stack();
475 rc = -EBADF;
476 goto reopen_error_exit;
479 inode = file->f_path.dentry->d_inode;
480 if (inode == NULL) {
481 cERROR(1, "inode not valid");
482 dump_stack();
483 rc = -EBADF;
484 goto reopen_error_exit;
487 cifs_sb = CIFS_SB(inode->i_sb);
488 tcon = cifs_sb->tcon;
490 /* can not grab rename sem here because various ops, including
491 those that already have the rename sem can end up causing writepage
492 to get called and if the server was down that means we end up here,
493 and we can never tell if the caller already has the rename_sem */
494 full_path = build_path_from_dentry(file->f_path.dentry);
495 if (full_path == NULL) {
496 rc = -ENOMEM;
497 reopen_error_exit:
498 mutex_unlock(&pCifsFile->fh_mutex);
499 FreeXid(xid);
500 return rc;
503 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
504 inode, file->f_flags, full_path);
506 if (oplockEnabled)
507 oplock = REQ_OPLOCK;
508 else
509 oplock = 0;
511 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
512 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
513 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
514 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
515 /* can not refresh inode info since size could be stale */
516 rc = cifs_posix_open(full_path, NULL, file->f_path.mnt,
517 inode->i_sb,
518 cifs_sb->mnt_file_mode /* ignored */,
519 oflags, &oplock, &netfid, xid);
520 if (rc == 0) {
521 cFYI(1, "posix reopen succeeded");
522 goto reopen_success;
524 /* fallthrough to retry open the old way on errors, especially
525 in the reconnect path it is important to retry hard */
528 desiredAccess = cifs_convert_flags(file->f_flags);
530 /* Can not refresh inode by passing in file_info buf to be returned
531 by SMBOpen and then calling get_inode_info with returned buf
532 since file might have write behind data that needs to be flushed
533 and server version of file size can be stale. If we knew for sure
534 that inode was not dirty locally we could do this */
536 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
537 CREATE_NOT_DIR, &netfid, &oplock, NULL,
538 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
539 CIFS_MOUNT_MAP_SPECIAL_CHR);
540 if (rc) {
541 mutex_unlock(&pCifsFile->fh_mutex);
542 cFYI(1, "cifs_open returned 0x%x", rc);
543 cFYI(1, "oplock: %d", oplock);
544 } else {
545 reopen_success:
546 pCifsFile->netfid = netfid;
547 pCifsFile->invalidHandle = false;
548 mutex_unlock(&pCifsFile->fh_mutex);
549 pCifsInode = CIFS_I(inode);
550 if (pCifsInode) {
551 if (can_flush) {
552 rc = filemap_write_and_wait(inode->i_mapping);
553 if (rc != 0)
554 CIFS_I(inode)->write_behind_rc = rc;
555 /* temporarily disable caching while we
556 go to server to get inode info */
557 pCifsInode->clientCanCacheAll = false;
558 pCifsInode->clientCanCacheRead = false;
559 if (tcon->unix_ext)
560 rc = cifs_get_inode_info_unix(&inode,
561 full_path, inode->i_sb, xid);
562 else
563 rc = cifs_get_inode_info(&inode,
564 full_path, NULL, inode->i_sb,
565 xid, NULL);
566 } /* else we are writing out data to server already
567 and could deadlock if we tried to flush data, and
568 since we do not know if we have data that would
569 invalidate the current end of file on the server
570 we can not go to the server to get the new inod
571 info */
572 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
573 pCifsInode->clientCanCacheAll = true;
574 pCifsInode->clientCanCacheRead = true;
575 cFYI(1, "Exclusive Oplock granted on inode %p",
576 file->f_path.dentry->d_inode);
577 } else if ((oplock & 0xF) == OPLOCK_READ) {
578 pCifsInode->clientCanCacheRead = true;
579 pCifsInode->clientCanCacheAll = false;
580 } else {
581 pCifsInode->clientCanCacheRead = false;
582 pCifsInode->clientCanCacheAll = false;
584 cifs_relock_file(pCifsFile);
587 kfree(full_path);
588 FreeXid(xid);
589 return rc;
592 int cifs_close(struct inode *inode, struct file *file)
594 int rc = 0;
595 int xid, timeout;
596 struct cifs_sb_info *cifs_sb;
597 struct cifsTconInfo *pTcon;
598 struct cifsFileInfo *pSMBFile =
599 (struct cifsFileInfo *)file->private_data;
601 xid = GetXid();
603 cifs_sb = CIFS_SB(inode->i_sb);
604 pTcon = cifs_sb->tcon;
605 if (pSMBFile) {
606 struct cifsLockInfo *li, *tmp;
607 write_lock(&GlobalSMBSeslock);
608 pSMBFile->closePend = true;
609 if (pTcon) {
610 /* no sense reconnecting to close a file that is
611 already closed */
612 if (!pTcon->need_reconnect) {
613 write_unlock(&GlobalSMBSeslock);
614 timeout = 2;
615 while ((atomic_read(&pSMBFile->count) != 1)
616 && (timeout <= 2048)) {
617 /* Give write a better chance to get to
618 server ahead of the close. We do not
619 want to add a wait_q here as it would
620 increase the memory utilization as
621 the struct would be in each open file,
622 but this should give enough time to
623 clear the socket */
624 cFYI(DBG2, "close delay, write pending");
625 msleep(timeout);
626 timeout *= 4;
628 if (!pTcon->need_reconnect &&
629 !pSMBFile->invalidHandle)
630 rc = CIFSSMBClose(xid, pTcon,
631 pSMBFile->netfid);
632 } else
633 write_unlock(&GlobalSMBSeslock);
634 } else
635 write_unlock(&GlobalSMBSeslock);
637 /* Delete any outstanding lock records.
638 We'll lose them when the file is closed anyway. */
639 mutex_lock(&pSMBFile->lock_mutex);
640 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
641 list_del(&li->llist);
642 kfree(li);
644 mutex_unlock(&pSMBFile->lock_mutex);
646 write_lock(&GlobalSMBSeslock);
647 list_del(&pSMBFile->flist);
648 list_del(&pSMBFile->tlist);
649 write_unlock(&GlobalSMBSeslock);
650 cifsFileInfo_put(file->private_data);
651 file->private_data = NULL;
652 } else
653 rc = -EBADF;
655 read_lock(&GlobalSMBSeslock);
656 if (list_empty(&(CIFS_I(inode)->openFileList))) {
657 cFYI(1, "closing last open instance for inode %p", inode);
658 /* if the file is not open we do not know if we can cache info
659 on this inode, much less write behind and read ahead */
660 CIFS_I(inode)->clientCanCacheRead = false;
661 CIFS_I(inode)->clientCanCacheAll = false;
663 read_unlock(&GlobalSMBSeslock);
664 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
665 rc = CIFS_I(inode)->write_behind_rc;
666 FreeXid(xid);
667 return rc;
670 int cifs_closedir(struct inode *inode, struct file *file)
672 int rc = 0;
673 int xid;
674 struct cifsFileInfo *pCFileStruct =
675 (struct cifsFileInfo *)file->private_data;
676 char *ptmp;
678 cFYI(1, "Closedir inode = 0x%p", inode);
680 xid = GetXid();
682 if (pCFileStruct) {
683 struct cifsTconInfo *pTcon;
684 struct cifs_sb_info *cifs_sb =
685 CIFS_SB(file->f_path.dentry->d_sb);
687 pTcon = cifs_sb->tcon;
689 cFYI(1, "Freeing private data in close dir");
690 write_lock(&GlobalSMBSeslock);
691 if (!pCFileStruct->srch_inf.endOfSearch &&
692 !pCFileStruct->invalidHandle) {
693 pCFileStruct->invalidHandle = true;
694 write_unlock(&GlobalSMBSeslock);
695 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
696 cFYI(1, "Closing uncompleted readdir with rc %d",
697 rc);
698 /* not much we can do if it fails anyway, ignore rc */
699 rc = 0;
700 } else
701 write_unlock(&GlobalSMBSeslock);
702 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
703 if (ptmp) {
704 cFYI(1, "closedir free smb buf in srch struct");
705 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
706 if (pCFileStruct->srch_inf.smallBuf)
707 cifs_small_buf_release(ptmp);
708 else
709 cifs_buf_release(ptmp);
711 kfree(file->private_data);
712 file->private_data = NULL;
714 /* BB can we lock the filestruct while this is going on? */
715 FreeXid(xid);
716 return rc;
719 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
720 __u64 offset, __u8 lockType)
722 struct cifsLockInfo *li =
723 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
724 if (li == NULL)
725 return -ENOMEM;
726 li->offset = offset;
727 li->length = len;
728 li->type = lockType;
729 mutex_lock(&fid->lock_mutex);
730 list_add(&li->llist, &fid->llist);
731 mutex_unlock(&fid->lock_mutex);
732 return 0;
735 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
737 int rc, xid;
738 __u32 numLock = 0;
739 __u32 numUnlock = 0;
740 __u64 length;
741 bool wait_flag = false;
742 struct cifs_sb_info *cifs_sb;
743 struct cifsTconInfo *tcon;
744 __u16 netfid;
745 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
746 bool posix_locking = 0;
748 length = 1 + pfLock->fl_end - pfLock->fl_start;
749 rc = -EACCES;
750 xid = GetXid();
752 cFYI(1, "Lock parm: 0x%x flockflags: "
753 "0x%x flocktype: 0x%x start: %lld end: %lld",
754 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
755 pfLock->fl_end);
757 if (pfLock->fl_flags & FL_POSIX)
758 cFYI(1, "Posix");
759 if (pfLock->fl_flags & FL_FLOCK)
760 cFYI(1, "Flock");
761 if (pfLock->fl_flags & FL_SLEEP) {
762 cFYI(1, "Blocking lock");
763 wait_flag = true;
765 if (pfLock->fl_flags & FL_ACCESS)
766 cFYI(1, "Process suspended by mandatory locking - "
767 "not implemented yet");
768 if (pfLock->fl_flags & FL_LEASE)
769 cFYI(1, "Lease on file - not implemented yet");
770 if (pfLock->fl_flags &
771 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
772 cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
774 if (pfLock->fl_type == F_WRLCK) {
775 cFYI(1, "F_WRLCK ");
776 numLock = 1;
777 } else if (pfLock->fl_type == F_UNLCK) {
778 cFYI(1, "F_UNLCK");
779 numUnlock = 1;
780 /* Check if unlock includes more than
781 one lock range */
782 } else if (pfLock->fl_type == F_RDLCK) {
783 cFYI(1, "F_RDLCK");
784 lockType |= LOCKING_ANDX_SHARED_LOCK;
785 numLock = 1;
786 } else if (pfLock->fl_type == F_EXLCK) {
787 cFYI(1, "F_EXLCK");
788 numLock = 1;
789 } else if (pfLock->fl_type == F_SHLCK) {
790 cFYI(1, "F_SHLCK");
791 lockType |= LOCKING_ANDX_SHARED_LOCK;
792 numLock = 1;
793 } else
794 cFYI(1, "Unknown type of lock");
796 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
797 tcon = cifs_sb->tcon;
799 if (file->private_data == NULL) {
800 rc = -EBADF;
801 FreeXid(xid);
802 return rc;
804 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
806 if ((tcon->ses->capabilities & CAP_UNIX) &&
807 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
808 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
809 posix_locking = 1;
810 /* BB add code here to normalize offset and length to
811 account for negative length which we can not accept over the
812 wire */
813 if (IS_GETLK(cmd)) {
814 if (posix_locking) {
815 int posix_lock_type;
816 if (lockType & LOCKING_ANDX_SHARED_LOCK)
817 posix_lock_type = CIFS_RDLCK;
818 else
819 posix_lock_type = CIFS_WRLCK;
820 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
821 length, pfLock,
822 posix_lock_type, wait_flag);
823 FreeXid(xid);
824 return rc;
827 /* BB we could chain these into one lock request BB */
828 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
829 0, 1, lockType, 0 /* wait flag */ );
830 if (rc == 0) {
831 rc = CIFSSMBLock(xid, tcon, netfid, length,
832 pfLock->fl_start, 1 /* numUnlock */ ,
833 0 /* numLock */ , lockType,
834 0 /* wait flag */ );
835 pfLock->fl_type = F_UNLCK;
836 if (rc != 0)
837 cERROR(1, "Error unlocking previously locked "
838 "range %d during test of lock", rc);
839 rc = 0;
841 } else {
842 /* if rc == ERR_SHARING_VIOLATION ? */
843 rc = 0;
845 if (lockType & LOCKING_ANDX_SHARED_LOCK) {
846 pfLock->fl_type = F_WRLCK;
847 } else {
848 rc = CIFSSMBLock(xid, tcon, netfid, length,
849 pfLock->fl_start, 0, 1,
850 lockType | LOCKING_ANDX_SHARED_LOCK,
851 0 /* wait flag */);
852 if (rc == 0) {
853 rc = CIFSSMBLock(xid, tcon, netfid,
854 length, pfLock->fl_start, 1, 0,
855 lockType |
856 LOCKING_ANDX_SHARED_LOCK,
857 0 /* wait flag */);
858 pfLock->fl_type = F_RDLCK;
859 if (rc != 0)
860 cERROR(1, "Error unlocking "
861 "previously locked range %d "
862 "during test of lock", rc);
863 rc = 0;
864 } else {
865 pfLock->fl_type = F_WRLCK;
866 rc = 0;
871 FreeXid(xid);
872 return rc;
875 if (!numLock && !numUnlock) {
876 /* if no lock or unlock then nothing
877 to do since we do not know what it is */
878 FreeXid(xid);
879 return -EOPNOTSUPP;
882 if (posix_locking) {
883 int posix_lock_type;
884 if (lockType & LOCKING_ANDX_SHARED_LOCK)
885 posix_lock_type = CIFS_RDLCK;
886 else
887 posix_lock_type = CIFS_WRLCK;
889 if (numUnlock == 1)
890 posix_lock_type = CIFS_UNLCK;
892 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
893 length, pfLock,
894 posix_lock_type, wait_flag);
895 } else {
896 struct cifsFileInfo *fid =
897 (struct cifsFileInfo *)file->private_data;
899 if (numLock) {
900 rc = CIFSSMBLock(xid, tcon, netfid, length,
901 pfLock->fl_start,
902 0, numLock, lockType, wait_flag);
904 if (rc == 0) {
905 /* For Windows locks we must store them. */
906 rc = store_file_lock(fid, length,
907 pfLock->fl_start, lockType);
909 } else if (numUnlock) {
910 /* For each stored lock that this unlock overlaps
911 completely, unlock it. */
912 int stored_rc = 0;
913 struct cifsLockInfo *li, *tmp;
915 rc = 0;
916 mutex_lock(&fid->lock_mutex);
917 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
918 if (pfLock->fl_start <= li->offset &&
919 (pfLock->fl_start + length) >=
920 (li->offset + li->length)) {
921 stored_rc = CIFSSMBLock(xid, tcon,
922 netfid,
923 li->length, li->offset,
924 1, 0, li->type, false);
925 if (stored_rc)
926 rc = stored_rc;
927 else {
928 list_del(&li->llist);
929 kfree(li);
933 mutex_unlock(&fid->lock_mutex);
937 if (pfLock->fl_flags & FL_POSIX)
938 posix_lock_file_wait(file, pfLock);
939 FreeXid(xid);
940 return rc;
944 * Set the timeout on write requests past EOF. For some servers (Windows)
945 * these calls can be very long.
947 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
948 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
949 * The 10M cutoff is totally arbitrary. A better scheme for this would be
950 * welcome if someone wants to suggest one.
952 * We may be able to do a better job with this if there were some way to
953 * declare that a file should be sparse.
955 static int
956 cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
958 if (offset <= cifsi->server_eof)
959 return CIFS_STD_OP;
960 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
961 return CIFS_VLONG_OP;
962 else
963 return CIFS_LONG_OP;
966 /* update the file size (if needed) after a write */
967 static void
968 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
969 unsigned int bytes_written)
971 loff_t end_of_write = offset + bytes_written;
973 if (end_of_write > cifsi->server_eof)
974 cifsi->server_eof = end_of_write;
977 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
978 size_t write_size, loff_t *poffset)
980 int rc = 0;
981 unsigned int bytes_written = 0;
982 unsigned int total_written;
983 struct cifs_sb_info *cifs_sb;
984 struct cifsTconInfo *pTcon;
985 int xid, long_op;
986 struct cifsFileInfo *open_file;
987 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
989 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
991 pTcon = cifs_sb->tcon;
993 /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
994 *poffset, file->f_path.dentry->d_name.name); */
996 if (file->private_data == NULL)
997 return -EBADF;
998 open_file = (struct cifsFileInfo *) file->private_data;
1000 rc = generic_write_checks(file, poffset, &write_size, 0);
1001 if (rc)
1002 return rc;
1004 xid = GetXid();
1006 long_op = cifs_write_timeout(cifsi, *poffset);
1007 for (total_written = 0; write_size > total_written;
1008 total_written += bytes_written) {
1009 rc = -EAGAIN;
1010 while (rc == -EAGAIN) {
1011 if (file->private_data == NULL) {
1012 /* file has been closed on us */
1013 FreeXid(xid);
1014 /* if we have gotten here we have written some data
1015 and blocked, and the file has been freed on us while
1016 we blocked so return what we managed to write */
1017 return total_written;
1019 if (open_file->closePend) {
1020 FreeXid(xid);
1021 if (total_written)
1022 return total_written;
1023 else
1024 return -EBADF;
1026 if (open_file->invalidHandle) {
1027 /* we could deadlock if we called
1028 filemap_fdatawait from here so tell
1029 reopen_file not to flush data to server
1030 now */
1031 rc = cifs_reopen_file(file, false);
1032 if (rc != 0)
1033 break;
1036 rc = CIFSSMBWrite(xid, pTcon,
1037 open_file->netfid,
1038 min_t(const int, cifs_sb->wsize,
1039 write_size - total_written),
1040 *poffset, &bytes_written,
1041 NULL, write_data + total_written, long_op);
1043 if (rc || (bytes_written == 0)) {
1044 if (total_written)
1045 break;
1046 else {
1047 FreeXid(xid);
1048 return rc;
1050 } else {
1051 cifs_update_eof(cifsi, *poffset, bytes_written);
1052 *poffset += bytes_written;
1054 long_op = CIFS_STD_OP; /* subsequent writes fast -
1055 15 seconds is plenty */
1058 cifs_stats_bytes_written(pTcon, total_written);
1060 /* since the write may have blocked check these pointers again */
1061 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1062 struct inode *inode = file->f_path.dentry->d_inode;
1063 /* Do not update local mtime - server will set its actual value on write
1064 * inode->i_ctime = inode->i_mtime =
1065 * current_fs_time(inode->i_sb);*/
1066 if (total_written > 0) {
1067 spin_lock(&inode->i_lock);
1068 if (*poffset > file->f_path.dentry->d_inode->i_size)
1069 i_size_write(file->f_path.dentry->d_inode,
1070 *poffset);
1071 spin_unlock(&inode->i_lock);
1073 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1075 FreeXid(xid);
1076 return total_written;
1079 static ssize_t cifs_write(struct file *file, const char *write_data,
1080 size_t write_size, loff_t *poffset)
1082 int rc = 0;
1083 unsigned int bytes_written = 0;
1084 unsigned int total_written;
1085 struct cifs_sb_info *cifs_sb;
1086 struct cifsTconInfo *pTcon;
1087 int xid, long_op;
1088 struct cifsFileInfo *open_file;
1089 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
1091 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1093 pTcon = cifs_sb->tcon;
1095 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1096 *poffset, file->f_path.dentry->d_name.name);
1098 if (file->private_data == NULL)
1099 return -EBADF;
1100 open_file = (struct cifsFileInfo *)file->private_data;
1102 xid = GetXid();
1104 long_op = cifs_write_timeout(cifsi, *poffset);
1105 for (total_written = 0; write_size > total_written;
1106 total_written += bytes_written) {
1107 rc = -EAGAIN;
1108 while (rc == -EAGAIN) {
1109 if (file->private_data == NULL) {
1110 /* file has been closed on us */
1111 FreeXid(xid);
1112 /* if we have gotten here we have written some data
1113 and blocked, and the file has been freed on us
1114 while we blocked so return what we managed to
1115 write */
1116 return total_written;
1118 if (open_file->closePend) {
1119 FreeXid(xid);
1120 if (total_written)
1121 return total_written;
1122 else
1123 return -EBADF;
1125 if (open_file->invalidHandle) {
1126 /* we could deadlock if we called
1127 filemap_fdatawait from here so tell
1128 reopen_file not to flush data to
1129 server now */
1130 rc = cifs_reopen_file(file, false);
1131 if (rc != 0)
1132 break;
1134 if (experimEnabled || (pTcon->ses->server &&
1135 ((pTcon->ses->server->secMode &
1136 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1137 == 0))) {
1138 struct kvec iov[2];
1139 unsigned int len;
1141 len = min((size_t)cifs_sb->wsize,
1142 write_size - total_written);
1143 /* iov[0] is reserved for smb header */
1144 iov[1].iov_base = (char *)write_data +
1145 total_written;
1146 iov[1].iov_len = len;
1147 rc = CIFSSMBWrite2(xid, pTcon,
1148 open_file->netfid, len,
1149 *poffset, &bytes_written,
1150 iov, 1, long_op);
1151 } else
1152 rc = CIFSSMBWrite(xid, pTcon,
1153 open_file->netfid,
1154 min_t(const int, cifs_sb->wsize,
1155 write_size - total_written),
1156 *poffset, &bytes_written,
1157 write_data + total_written,
1158 NULL, long_op);
1160 if (rc || (bytes_written == 0)) {
1161 if (total_written)
1162 break;
1163 else {
1164 FreeXid(xid);
1165 return rc;
1167 } else {
1168 cifs_update_eof(cifsi, *poffset, bytes_written);
1169 *poffset += bytes_written;
1171 long_op = CIFS_STD_OP; /* subsequent writes fast -
1172 15 seconds is plenty */
1175 cifs_stats_bytes_written(pTcon, total_written);
1177 /* since the write may have blocked check these pointers again */
1178 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1179 /*BB We could make this contingent on superblock ATIME flag too */
1180 /* file->f_path.dentry->d_inode->i_ctime =
1181 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1182 if (total_written > 0) {
1183 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1184 if (*poffset > file->f_path.dentry->d_inode->i_size)
1185 i_size_write(file->f_path.dentry->d_inode,
1186 *poffset);
1187 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
1189 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1191 FreeXid(xid);
1192 return total_written;
1195 #ifdef CONFIG_CIFS_EXPERIMENTAL
1196 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1198 struct cifsFileInfo *open_file = NULL;
1200 read_lock(&GlobalSMBSeslock);
1201 /* we could simply get the first_list_entry since write-only entries
1202 are always at the end of the list but since the first entry might
1203 have a close pending, we go through the whole list */
1204 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1205 if (open_file->closePend)
1206 continue;
1207 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1208 (open_file->pfile->f_flags & O_RDONLY))) {
1209 if (!open_file->invalidHandle) {
1210 /* found a good file */
1211 /* lock it so it will not be closed on us */
1212 cifsFileInfo_get(open_file);
1213 read_unlock(&GlobalSMBSeslock);
1214 return open_file;
1215 } /* else might as well continue, and look for
1216 another, or simply have the caller reopen it
1217 again rather than trying to fix this handle */
1218 } else /* write only file */
1219 break; /* write only files are last so must be done */
1221 read_unlock(&GlobalSMBSeslock);
1222 return NULL;
1224 #endif
1226 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
1228 struct cifsFileInfo *open_file;
1229 bool any_available = false;
1230 int rc;
1232 /* Having a null inode here (because mapping->host was set to zero by
1233 the VFS or MM) should not happen but we had reports of on oops (due to
1234 it being zero) during stress testcases so we need to check for it */
1236 if (cifs_inode == NULL) {
1237 cERROR(1, "Null inode passed to cifs_writeable_file");
1238 dump_stack();
1239 return NULL;
1242 read_lock(&GlobalSMBSeslock);
1243 refind_writable:
1244 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1245 if (open_file->closePend ||
1246 (!any_available && open_file->pid != current->tgid))
1247 continue;
1249 if (open_file->pfile &&
1250 ((open_file->pfile->f_flags & O_RDWR) ||
1251 (open_file->pfile->f_flags & O_WRONLY))) {
1252 cifsFileInfo_get(open_file);
1254 if (!open_file->invalidHandle) {
1255 /* found a good writable file */
1256 read_unlock(&GlobalSMBSeslock);
1257 return open_file;
1260 read_unlock(&GlobalSMBSeslock);
1261 /* Had to unlock since following call can block */
1262 rc = cifs_reopen_file(open_file->pfile, false);
1263 if (!rc) {
1264 if (!open_file->closePend)
1265 return open_file;
1266 else { /* start over in case this was deleted */
1267 /* since the list could be modified */
1268 read_lock(&GlobalSMBSeslock);
1269 cifsFileInfo_put(open_file);
1270 goto refind_writable;
1274 /* if it fails, try another handle if possible -
1275 (we can not do this if closePending since
1276 loop could be modified - in which case we
1277 have to start at the beginning of the list
1278 again. Note that it would be bad
1279 to hold up writepages here (rather than
1280 in caller) with continuous retries */
1281 cFYI(1, "wp failed on reopen file");
1282 read_lock(&GlobalSMBSeslock);
1283 /* can not use this handle, no write
1284 pending on this one after all */
1285 cifsFileInfo_put(open_file);
1287 if (open_file->closePend) /* list could have changed */
1288 goto refind_writable;
1289 /* else we simply continue to the next entry. Thus
1290 we do not loop on reopen errors. If we
1291 can not reopen the file, for example if we
1292 reconnected to a server with another client
1293 racing to delete or lock the file we would not
1294 make progress if we restarted before the beginning
1295 of the loop here. */
1298 /* couldn't find useable FH with same pid, try any available */
1299 if (!any_available) {
1300 any_available = true;
1301 goto refind_writable;
1303 read_unlock(&GlobalSMBSeslock);
1304 return NULL;
1307 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1309 struct address_space *mapping = page->mapping;
1310 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1311 char *write_data;
1312 int rc = -EFAULT;
1313 int bytes_written = 0;
1314 struct cifs_sb_info *cifs_sb;
1315 struct cifsTconInfo *pTcon;
1316 struct inode *inode;
1317 struct cifsFileInfo *open_file;
1319 if (!mapping || !mapping->host)
1320 return -EFAULT;
1322 inode = page->mapping->host;
1323 cifs_sb = CIFS_SB(inode->i_sb);
1324 pTcon = cifs_sb->tcon;
1326 offset += (loff_t)from;
1327 write_data = kmap(page);
1328 write_data += from;
1330 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1331 kunmap(page);
1332 return -EIO;
1335 /* racing with truncate? */
1336 if (offset > mapping->host->i_size) {
1337 kunmap(page);
1338 return 0; /* don't care */
1341 /* check to make sure that we are not extending the file */
1342 if (mapping->host->i_size - offset < (loff_t)to)
1343 to = (unsigned)(mapping->host->i_size - offset);
1345 open_file = find_writable_file(CIFS_I(mapping->host));
1346 if (open_file) {
1347 bytes_written = cifs_write(open_file->pfile, write_data,
1348 to-from, &offset);
1349 cifsFileInfo_put(open_file);
1350 /* Does mm or vfs already set times? */
1351 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1352 if ((bytes_written > 0) && (offset))
1353 rc = 0;
1354 else if (bytes_written < 0)
1355 rc = bytes_written;
1356 } else {
1357 cFYI(1, "No writeable filehandles for inode");
1358 rc = -EIO;
1361 kunmap(page);
1362 return rc;
1365 static int cifs_writepages(struct address_space *mapping,
1366 struct writeback_control *wbc)
1368 struct backing_dev_info *bdi = mapping->backing_dev_info;
1369 unsigned int bytes_to_write;
1370 unsigned int bytes_written;
1371 struct cifs_sb_info *cifs_sb;
1372 int done = 0;
1373 pgoff_t end;
1374 pgoff_t index;
1375 int range_whole = 0;
1376 struct kvec *iov;
1377 int len;
1378 int n_iov = 0;
1379 pgoff_t next;
1380 int nr_pages;
1381 __u64 offset = 0;
1382 struct cifsFileInfo *open_file;
1383 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1384 struct page *page;
1385 struct pagevec pvec;
1386 int rc = 0;
1387 int scanned = 0;
1388 int xid, long_op;
1390 cifs_sb = CIFS_SB(mapping->host->i_sb);
1393 * If wsize is smaller that the page cache size, default to writing
1394 * one page at a time via cifs_writepage
1396 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1397 return generic_writepages(mapping, wbc);
1399 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1400 if (cifs_sb->tcon->ses->server->secMode &
1401 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1402 if (!experimEnabled)
1403 return generic_writepages(mapping, wbc);
1405 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1406 if (iov == NULL)
1407 return generic_writepages(mapping, wbc);
1411 * BB: Is this meaningful for a non-block-device file system?
1412 * If it is, we should test it again after we do I/O
1414 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1415 wbc->encountered_congestion = 1;
1416 kfree(iov);
1417 return 0;
1420 xid = GetXid();
1422 pagevec_init(&pvec, 0);
1423 if (wbc->range_cyclic) {
1424 index = mapping->writeback_index; /* Start from prev offset */
1425 end = -1;
1426 } else {
1427 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1428 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1429 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1430 range_whole = 1;
1431 scanned = 1;
1433 retry:
1434 while (!done && (index <= end) &&
1435 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1436 PAGECACHE_TAG_DIRTY,
1437 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1438 int first;
1439 unsigned int i;
1441 first = -1;
1442 next = 0;
1443 n_iov = 0;
1444 bytes_to_write = 0;
1446 for (i = 0; i < nr_pages; i++) {
1447 page = pvec.pages[i];
1449 * At this point we hold neither mapping->tree_lock nor
1450 * lock on the page itself: the page may be truncated or
1451 * invalidated (changing page->mapping to NULL), or even
1452 * swizzled back from swapper_space to tmpfs file
1453 * mapping
1456 if (first < 0)
1457 lock_page(page);
1458 else if (!trylock_page(page))
1459 break;
1461 if (unlikely(page->mapping != mapping)) {
1462 unlock_page(page);
1463 break;
1466 if (!wbc->range_cyclic && page->index > end) {
1467 done = 1;
1468 unlock_page(page);
1469 break;
1472 if (next && (page->index != next)) {
1473 /* Not next consecutive page */
1474 unlock_page(page);
1475 break;
1478 if (wbc->sync_mode != WB_SYNC_NONE)
1479 wait_on_page_writeback(page);
1481 if (PageWriteback(page) ||
1482 !clear_page_dirty_for_io(page)) {
1483 unlock_page(page);
1484 break;
1488 * This actually clears the dirty bit in the radix tree.
1489 * See cifs_writepage() for more commentary.
1491 set_page_writeback(page);
1493 if (page_offset(page) >= mapping->host->i_size) {
1494 done = 1;
1495 unlock_page(page);
1496 end_page_writeback(page);
1497 break;
1501 * BB can we get rid of this? pages are held by pvec
1503 page_cache_get(page);
1505 len = min(mapping->host->i_size - page_offset(page),
1506 (loff_t)PAGE_CACHE_SIZE);
1508 /* reserve iov[0] for the smb header */
1509 n_iov++;
1510 iov[n_iov].iov_base = kmap(page);
1511 iov[n_iov].iov_len = len;
1512 bytes_to_write += len;
1514 if (first < 0) {
1515 first = i;
1516 offset = page_offset(page);
1518 next = page->index + 1;
1519 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1520 break;
1522 if (n_iov) {
1523 /* Search for a writable handle every time we call
1524 * CIFSSMBWrite2. We can't rely on the last handle
1525 * we used to still be valid
1527 open_file = find_writable_file(CIFS_I(mapping->host));
1528 if (!open_file) {
1529 cERROR(1, "No writable handles for inode");
1530 rc = -EBADF;
1531 } else {
1532 long_op = cifs_write_timeout(cifsi, offset);
1533 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1534 open_file->netfid,
1535 bytes_to_write, offset,
1536 &bytes_written, iov, n_iov,
1537 long_op);
1538 cifsFileInfo_put(open_file);
1539 cifs_update_eof(cifsi, offset, bytes_written);
1541 if (rc || bytes_written < bytes_to_write) {
1542 cERROR(1, "Write2 ret %d, wrote %d",
1543 rc, bytes_written);
1544 /* BB what if continued retry is
1545 requested via mount flags? */
1546 if (rc == -ENOSPC)
1547 set_bit(AS_ENOSPC, &mapping->flags);
1548 else
1549 set_bit(AS_EIO, &mapping->flags);
1550 } else {
1551 cifs_stats_bytes_written(cifs_sb->tcon,
1552 bytes_written);
1555 for (i = 0; i < n_iov; i++) {
1556 page = pvec.pages[first + i];
1557 /* Should we also set page error on
1558 success rc but too little data written? */
1559 /* BB investigate retry logic on temporary
1560 server crash cases and how recovery works
1561 when page marked as error */
1562 if (rc)
1563 SetPageError(page);
1564 kunmap(page);
1565 unlock_page(page);
1566 end_page_writeback(page);
1567 page_cache_release(page);
1569 if ((wbc->nr_to_write -= n_iov) <= 0)
1570 done = 1;
1571 index = next;
1572 } else
1573 /* Need to re-find the pages we skipped */
1574 index = pvec.pages[0]->index + 1;
1576 pagevec_release(&pvec);
1578 if (!scanned && !done) {
1580 * We hit the last page and there is more work to be done: wrap
1581 * back to the start of the file
1583 scanned = 1;
1584 index = 0;
1585 goto retry;
1587 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1588 mapping->writeback_index = index;
1590 FreeXid(xid);
1591 kfree(iov);
1592 return rc;
1595 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1597 int rc = -EFAULT;
1598 int xid;
1600 xid = GetXid();
1601 /* BB add check for wbc flags */
1602 page_cache_get(page);
1603 if (!PageUptodate(page))
1604 cFYI(1, "ppw - page not up to date");
1607 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1609 * A writepage() implementation always needs to do either this,
1610 * or re-dirty the page with "redirty_page_for_writepage()" in
1611 * the case of a failure.
1613 * Just unlocking the page will cause the radix tree tag-bits
1614 * to fail to update with the state of the page correctly.
1616 set_page_writeback(page);
1617 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1618 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1619 unlock_page(page);
1620 end_page_writeback(page);
1621 page_cache_release(page);
1622 FreeXid(xid);
1623 return rc;
1626 static int cifs_write_end(struct file *file, struct address_space *mapping,
1627 loff_t pos, unsigned len, unsigned copied,
1628 struct page *page, void *fsdata)
1630 int rc;
1631 struct inode *inode = mapping->host;
1633 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1634 page, pos, copied);
1636 if (PageChecked(page)) {
1637 if (copied == len)
1638 SetPageUptodate(page);
1639 ClearPageChecked(page);
1640 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1641 SetPageUptodate(page);
1643 if (!PageUptodate(page)) {
1644 char *page_data;
1645 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1646 int xid;
1648 xid = GetXid();
1649 /* this is probably better than directly calling
1650 partialpage_write since in this function the file handle is
1651 known which we might as well leverage */
1652 /* BB check if anything else missing out of ppw
1653 such as updating last write time */
1654 page_data = kmap(page);
1655 rc = cifs_write(file, page_data + offset, copied, &pos);
1656 /* if (rc < 0) should we set writebehind rc? */
1657 kunmap(page);
1659 FreeXid(xid);
1660 } else {
1661 rc = copied;
1662 pos += copied;
1663 set_page_dirty(page);
1666 if (rc > 0) {
1667 spin_lock(&inode->i_lock);
1668 if (pos > inode->i_size)
1669 i_size_write(inode, pos);
1670 spin_unlock(&inode->i_lock);
1673 unlock_page(page);
1674 page_cache_release(page);
1676 return rc;
1679 int cifs_fsync(struct file *file, int datasync)
1681 int xid;
1682 int rc = 0;
1683 struct cifsTconInfo *tcon;
1684 struct cifsFileInfo *smbfile =
1685 (struct cifsFileInfo *)file->private_data;
1686 struct inode *inode = file->f_path.dentry->d_inode;
1688 xid = GetXid();
1690 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1691 file->f_path.dentry->d_name.name, datasync);
1693 rc = filemap_write_and_wait(inode->i_mapping);
1694 if (rc == 0) {
1695 rc = CIFS_I(inode)->write_behind_rc;
1696 CIFS_I(inode)->write_behind_rc = 0;
1697 tcon = CIFS_SB(inode->i_sb)->tcon;
1698 if (!rc && tcon && smbfile &&
1699 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1700 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1703 FreeXid(xid);
1704 return rc;
1707 /* static void cifs_sync_page(struct page *page)
1709 struct address_space *mapping;
1710 struct inode *inode;
1711 unsigned long index = page->index;
1712 unsigned int rpages = 0;
1713 int rc = 0;
1715 cFYI(1, "sync page %p", page);
1716 mapping = page->mapping;
1717 if (!mapping)
1718 return 0;
1719 inode = mapping->host;
1720 if (!inode)
1721 return; */
1723 /* fill in rpages then
1724 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1726 /* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
1728 #if 0
1729 if (rc < 0)
1730 return rc;
1731 return 0;
1732 #endif
1733 } */
1736 * As file closes, flush all cached write data for this inode checking
1737 * for write behind errors.
1739 int cifs_flush(struct file *file, fl_owner_t id)
1741 struct inode *inode = file->f_path.dentry->d_inode;
1742 int rc = 0;
1744 /* Rather than do the steps manually:
1745 lock the inode for writing
1746 loop through pages looking for write behind data (dirty pages)
1747 coalesce into contiguous 16K (or smaller) chunks to write to server
1748 send to server (prefer in parallel)
1749 deal with writebehind errors
1750 unlock inode for writing
1751 filemapfdatawrite appears easier for the time being */
1753 rc = filemap_fdatawrite(inode->i_mapping);
1754 /* reset wb rc if we were able to write out dirty pages */
1755 if (!rc) {
1756 rc = CIFS_I(inode)->write_behind_rc;
1757 CIFS_I(inode)->write_behind_rc = 0;
1760 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1762 return rc;
1765 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1766 size_t read_size, loff_t *poffset)
1768 int rc = -EACCES;
1769 unsigned int bytes_read = 0;
1770 unsigned int total_read = 0;
1771 unsigned int current_read_size;
1772 struct cifs_sb_info *cifs_sb;
1773 struct cifsTconInfo *pTcon;
1774 int xid;
1775 struct cifsFileInfo *open_file;
1776 char *smb_read_data;
1777 char __user *current_offset;
1778 struct smb_com_read_rsp *pSMBr;
1780 xid = GetXid();
1781 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1782 pTcon = cifs_sb->tcon;
1784 if (file->private_data == NULL) {
1785 rc = -EBADF;
1786 FreeXid(xid);
1787 return rc;
1789 open_file = (struct cifsFileInfo *)file->private_data;
1791 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1792 cFYI(1, "attempting read on write only file instance");
1794 for (total_read = 0, current_offset = read_data;
1795 read_size > total_read;
1796 total_read += bytes_read, current_offset += bytes_read) {
1797 current_read_size = min_t(const int, read_size - total_read,
1798 cifs_sb->rsize);
1799 rc = -EAGAIN;
1800 smb_read_data = NULL;
1801 while (rc == -EAGAIN) {
1802 int buf_type = CIFS_NO_BUFFER;
1803 if ((open_file->invalidHandle) &&
1804 (!open_file->closePend)) {
1805 rc = cifs_reopen_file(file, true);
1806 if (rc != 0)
1807 break;
1809 rc = CIFSSMBRead(xid, pTcon,
1810 open_file->netfid,
1811 current_read_size, *poffset,
1812 &bytes_read, &smb_read_data,
1813 &buf_type);
1814 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1815 if (smb_read_data) {
1816 if (copy_to_user(current_offset,
1817 smb_read_data +
1818 4 /* RFC1001 length field */ +
1819 le16_to_cpu(pSMBr->DataOffset),
1820 bytes_read))
1821 rc = -EFAULT;
1823 if (buf_type == CIFS_SMALL_BUFFER)
1824 cifs_small_buf_release(smb_read_data);
1825 else if (buf_type == CIFS_LARGE_BUFFER)
1826 cifs_buf_release(smb_read_data);
1827 smb_read_data = NULL;
1830 if (rc || (bytes_read == 0)) {
1831 if (total_read) {
1832 break;
1833 } else {
1834 FreeXid(xid);
1835 return rc;
1837 } else {
1838 cifs_stats_bytes_read(pTcon, bytes_read);
1839 *poffset += bytes_read;
1842 FreeXid(xid);
1843 return total_read;
1847 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1848 loff_t *poffset)
1850 int rc = -EACCES;
1851 unsigned int bytes_read = 0;
1852 unsigned int total_read;
1853 unsigned int current_read_size;
1854 struct cifs_sb_info *cifs_sb;
1855 struct cifsTconInfo *pTcon;
1856 int xid;
1857 char *current_offset;
1858 struct cifsFileInfo *open_file;
1859 int buf_type = CIFS_NO_BUFFER;
1861 xid = GetXid();
1862 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1863 pTcon = cifs_sb->tcon;
1865 if (file->private_data == NULL) {
1866 rc = -EBADF;
1867 FreeXid(xid);
1868 return rc;
1870 open_file = (struct cifsFileInfo *)file->private_data;
1872 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1873 cFYI(1, "attempting read on write only file instance");
1875 for (total_read = 0, current_offset = read_data;
1876 read_size > total_read;
1877 total_read += bytes_read, current_offset += bytes_read) {
1878 current_read_size = min_t(const int, read_size - total_read,
1879 cifs_sb->rsize);
1880 /* For windows me and 9x we do not want to request more
1881 than it negotiated since it will refuse the read then */
1882 if ((pTcon->ses) &&
1883 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1884 current_read_size = min_t(const int, current_read_size,
1885 pTcon->ses->server->maxBuf - 128);
1887 rc = -EAGAIN;
1888 while (rc == -EAGAIN) {
1889 if ((open_file->invalidHandle) &&
1890 (!open_file->closePend)) {
1891 rc = cifs_reopen_file(file, true);
1892 if (rc != 0)
1893 break;
1895 rc = CIFSSMBRead(xid, pTcon,
1896 open_file->netfid,
1897 current_read_size, *poffset,
1898 &bytes_read, &current_offset,
1899 &buf_type);
1901 if (rc || (bytes_read == 0)) {
1902 if (total_read) {
1903 break;
1904 } else {
1905 FreeXid(xid);
1906 return rc;
1908 } else {
1909 cifs_stats_bytes_read(pTcon, total_read);
1910 *poffset += bytes_read;
1913 FreeXid(xid);
1914 return total_read;
1917 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1919 int rc, xid;
1921 xid = GetXid();
1922 rc = cifs_revalidate_file(file);
1923 if (rc) {
1924 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
1925 FreeXid(xid);
1926 return rc;
1928 rc = generic_file_mmap(file, vma);
1929 FreeXid(xid);
1930 return rc;
1934 static void cifs_copy_cache_pages(struct address_space *mapping,
1935 struct list_head *pages, int bytes_read, char *data)
1937 struct page *page;
1938 char *target;
1940 while (bytes_read > 0) {
1941 if (list_empty(pages))
1942 break;
1944 page = list_entry(pages->prev, struct page, lru);
1945 list_del(&page->lru);
1947 if (add_to_page_cache_lru(page, mapping, page->index,
1948 GFP_KERNEL)) {
1949 page_cache_release(page);
1950 cFYI(1, "Add page cache failed");
1951 data += PAGE_CACHE_SIZE;
1952 bytes_read -= PAGE_CACHE_SIZE;
1953 continue;
1955 page_cache_release(page);
1957 target = kmap_atomic(page, KM_USER0);
1959 if (PAGE_CACHE_SIZE > bytes_read) {
1960 memcpy(target, data, bytes_read);
1961 /* zero the tail end of this partial page */
1962 memset(target + bytes_read, 0,
1963 PAGE_CACHE_SIZE - bytes_read);
1964 bytes_read = 0;
1965 } else {
1966 memcpy(target, data, PAGE_CACHE_SIZE);
1967 bytes_read -= PAGE_CACHE_SIZE;
1969 kunmap_atomic(target, KM_USER0);
1971 flush_dcache_page(page);
1972 SetPageUptodate(page);
1973 unlock_page(page);
1974 data += PAGE_CACHE_SIZE;
1976 return;
1979 static int cifs_readpages(struct file *file, struct address_space *mapping,
1980 struct list_head *page_list, unsigned num_pages)
1982 int rc = -EACCES;
1983 int xid;
1984 loff_t offset;
1985 struct page *page;
1986 struct cifs_sb_info *cifs_sb;
1987 struct cifsTconInfo *pTcon;
1988 unsigned int bytes_read = 0;
1989 unsigned int read_size, i;
1990 char *smb_read_data = NULL;
1991 struct smb_com_read_rsp *pSMBr;
1992 struct cifsFileInfo *open_file;
1993 int buf_type = CIFS_NO_BUFFER;
1995 xid = GetXid();
1996 if (file->private_data == NULL) {
1997 rc = -EBADF;
1998 FreeXid(xid);
1999 return rc;
2001 open_file = (struct cifsFileInfo *)file->private_data;
2002 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2003 pTcon = cifs_sb->tcon;
2005 cFYI(DBG2, "rpages: num pages %d", num_pages);
2006 for (i = 0; i < num_pages; ) {
2007 unsigned contig_pages;
2008 struct page *tmp_page;
2009 unsigned long expected_index;
2011 if (list_empty(page_list))
2012 break;
2014 page = list_entry(page_list->prev, struct page, lru);
2015 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2017 /* count adjacent pages that we will read into */
2018 contig_pages = 0;
2019 expected_index =
2020 list_entry(page_list->prev, struct page, lru)->index;
2021 list_for_each_entry_reverse(tmp_page, page_list, lru) {
2022 if (tmp_page->index == expected_index) {
2023 contig_pages++;
2024 expected_index++;
2025 } else
2026 break;
2028 if (contig_pages + i > num_pages)
2029 contig_pages = num_pages - i;
2031 /* for reads over a certain size could initiate async
2032 read ahead */
2034 read_size = contig_pages * PAGE_CACHE_SIZE;
2035 /* Read size needs to be in multiples of one page */
2036 read_size = min_t(const unsigned int, read_size,
2037 cifs_sb->rsize & PAGE_CACHE_MASK);
2038 cFYI(DBG2, "rpages: read size 0x%x contiguous pages %d",
2039 read_size, contig_pages);
2040 rc = -EAGAIN;
2041 while (rc == -EAGAIN) {
2042 if ((open_file->invalidHandle) &&
2043 (!open_file->closePend)) {
2044 rc = cifs_reopen_file(file, true);
2045 if (rc != 0)
2046 break;
2049 rc = CIFSSMBRead(xid, pTcon,
2050 open_file->netfid,
2051 read_size, offset,
2052 &bytes_read, &smb_read_data,
2053 &buf_type);
2054 /* BB more RC checks ? */
2055 if (rc == -EAGAIN) {
2056 if (smb_read_data) {
2057 if (buf_type == CIFS_SMALL_BUFFER)
2058 cifs_small_buf_release(smb_read_data);
2059 else if (buf_type == CIFS_LARGE_BUFFER)
2060 cifs_buf_release(smb_read_data);
2061 smb_read_data = NULL;
2065 if ((rc < 0) || (smb_read_data == NULL)) {
2066 cFYI(1, "Read error in readpages: %d", rc);
2067 break;
2068 } else if (bytes_read > 0) {
2069 task_io_account_read(bytes_read);
2070 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2071 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2072 smb_read_data + 4 /* RFC1001 hdr */ +
2073 le16_to_cpu(pSMBr->DataOffset));
2075 i += bytes_read >> PAGE_CACHE_SHIFT;
2076 cifs_stats_bytes_read(pTcon, bytes_read);
2077 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2078 i++; /* account for partial page */
2080 /* server copy of file can have smaller size
2081 than client */
2082 /* BB do we need to verify this common case ?
2083 this case is ok - if we are at server EOF
2084 we will hit it on next read */
2086 /* break; */
2088 } else {
2089 cFYI(1, "No bytes read (%d) at offset %lld . "
2090 "Cleaning remaining pages from readahead list",
2091 bytes_read, offset);
2092 /* BB turn off caching and do new lookup on
2093 file size at server? */
2094 break;
2096 if (smb_read_data) {
2097 if (buf_type == CIFS_SMALL_BUFFER)
2098 cifs_small_buf_release(smb_read_data);
2099 else if (buf_type == CIFS_LARGE_BUFFER)
2100 cifs_buf_release(smb_read_data);
2101 smb_read_data = NULL;
2103 bytes_read = 0;
2106 /* need to free smb_read_data buf before exit */
2107 if (smb_read_data) {
2108 if (buf_type == CIFS_SMALL_BUFFER)
2109 cifs_small_buf_release(smb_read_data);
2110 else if (buf_type == CIFS_LARGE_BUFFER)
2111 cifs_buf_release(smb_read_data);
2112 smb_read_data = NULL;
2115 FreeXid(xid);
2116 return rc;
2119 static int cifs_readpage_worker(struct file *file, struct page *page,
2120 loff_t *poffset)
2122 char *read_data;
2123 int rc;
2125 page_cache_get(page);
2126 read_data = kmap(page);
2127 /* for reads over a certain size could initiate async read ahead */
2129 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2131 if (rc < 0)
2132 goto io_error;
2133 else
2134 cFYI(1, "Bytes read %d", rc);
2136 file->f_path.dentry->d_inode->i_atime =
2137 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2139 if (PAGE_CACHE_SIZE > rc)
2140 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2142 flush_dcache_page(page);
2143 SetPageUptodate(page);
2144 rc = 0;
2146 io_error:
2147 kunmap(page);
2148 page_cache_release(page);
2149 return rc;
2152 static int cifs_readpage(struct file *file, struct page *page)
2154 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2155 int rc = -EACCES;
2156 int xid;
2158 xid = GetXid();
2160 if (file->private_data == NULL) {
2161 rc = -EBADF;
2162 FreeXid(xid);
2163 return rc;
2166 cFYI(1, "readpage %p at offset %d 0x%x\n",
2167 page, (int)offset, (int)offset);
2169 rc = cifs_readpage_worker(file, page, &offset);
2171 unlock_page(page);
2173 FreeXid(xid);
2174 return rc;
2177 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2179 struct cifsFileInfo *open_file;
2181 read_lock(&GlobalSMBSeslock);
2182 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2183 if (open_file->closePend)
2184 continue;
2185 if (open_file->pfile &&
2186 ((open_file->pfile->f_flags & O_RDWR) ||
2187 (open_file->pfile->f_flags & O_WRONLY))) {
2188 read_unlock(&GlobalSMBSeslock);
2189 return 1;
2192 read_unlock(&GlobalSMBSeslock);
2193 return 0;
2196 /* We do not want to update the file size from server for inodes
2197 open for write - to avoid races with writepage extending
2198 the file - in the future we could consider allowing
2199 refreshing the inode only on increases in the file size
2200 but this is tricky to do without racing with writebehind
2201 page caching in the current Linux kernel design */
2202 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2204 if (!cifsInode)
2205 return true;
2207 if (is_inode_writable(cifsInode)) {
2208 /* This inode is open for write at least once */
2209 struct cifs_sb_info *cifs_sb;
2211 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2212 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2213 /* since no page cache to corrupt on directio
2214 we can change size safely */
2215 return true;
2218 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2219 return true;
2221 return false;
2222 } else
2223 return true;
2226 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2227 loff_t pos, unsigned len, unsigned flags,
2228 struct page **pagep, void **fsdata)
2230 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2231 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2232 loff_t page_start = pos & PAGE_MASK;
2233 loff_t i_size;
2234 struct page *page;
2235 int rc = 0;
2237 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2239 page = grab_cache_page_write_begin(mapping, index, flags);
2240 if (!page) {
2241 rc = -ENOMEM;
2242 goto out;
2245 if (PageUptodate(page))
2246 goto out;
2249 * If we write a full page it will be up to date, no need to read from
2250 * the server. If the write is short, we'll end up doing a sync write
2251 * instead.
2253 if (len == PAGE_CACHE_SIZE)
2254 goto out;
2257 * optimize away the read when we have an oplock, and we're not
2258 * expecting to use any of the data we'd be reading in. That
2259 * is, when the page lies beyond the EOF, or straddles the EOF
2260 * and the write will cover all of the existing data.
2262 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2263 i_size = i_size_read(mapping->host);
2264 if (page_start >= i_size ||
2265 (offset == 0 && (pos + len) >= i_size)) {
2266 zero_user_segments(page, 0, offset,
2267 offset + len,
2268 PAGE_CACHE_SIZE);
2270 * PageChecked means that the parts of the page
2271 * to which we're not writing are considered up
2272 * to date. Once the data is copied to the
2273 * page, it can be set uptodate.
2275 SetPageChecked(page);
2276 goto out;
2280 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2282 * might as well read a page, it is fast enough. If we get
2283 * an error, we don't need to return it. cifs_write_end will
2284 * do a sync write instead since PG_uptodate isn't set.
2286 cifs_readpage_worker(file, page, &page_start);
2287 } else {
2288 /* we could try using another file handle if there is one -
2289 but how would we lock it to prevent close of that handle
2290 racing with this read? In any case
2291 this will be written out by write_end so is fine */
2293 out:
2294 *pagep = page;
2295 return rc;
2298 static void
2299 cifs_oplock_break(struct slow_work *work)
2301 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2302 oplock_break);
2303 struct inode *inode = cfile->pInode;
2304 struct cifsInodeInfo *cinode = CIFS_I(inode);
2305 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->mnt->mnt_sb);
2306 int rc, waitrc = 0;
2308 if (inode && S_ISREG(inode->i_mode)) {
2309 if (cinode->clientCanCacheRead)
2310 break_lease(inode, O_RDONLY);
2311 else
2312 break_lease(inode, O_WRONLY);
2313 rc = filemap_fdatawrite(inode->i_mapping);
2314 if (cinode->clientCanCacheRead == 0) {
2315 waitrc = filemap_fdatawait(inode->i_mapping);
2316 invalidate_remote_inode(inode);
2318 if (!rc)
2319 rc = waitrc;
2320 if (rc)
2321 cinode->write_behind_rc = rc;
2322 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2326 * releasing stale oplock after recent reconnect of smb session using
2327 * a now incorrect file handle is not a data integrity issue but do
2328 * not bother sending an oplock release if session to server still is
2329 * disconnected since oplock already released by the server
2331 if (!cfile->closePend && !cfile->oplock_break_cancelled) {
2332 rc = CIFSSMBLock(0, cifs_sb->tcon, cfile->netfid, 0, 0, 0, 0,
2333 LOCKING_ANDX_OPLOCK_RELEASE, false);
2334 cFYI(1, "Oplock release rc = %d", rc);
2338 static int
2339 cifs_oplock_break_get(struct slow_work *work)
2341 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2342 oplock_break);
2343 mntget(cfile->mnt);
2344 cifsFileInfo_get(cfile);
2345 return 0;
2348 static void
2349 cifs_oplock_break_put(struct slow_work *work)
2351 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2352 oplock_break);
2353 mntput(cfile->mnt);
2354 cifsFileInfo_put(cfile);
2357 const struct slow_work_ops cifs_oplock_break_ops = {
2358 .get_ref = cifs_oplock_break_get,
2359 .put_ref = cifs_oplock_break_put,
2360 .execute = cifs_oplock_break,
2363 const struct address_space_operations cifs_addr_ops = {
2364 .readpage = cifs_readpage,
2365 .readpages = cifs_readpages,
2366 .writepage = cifs_writepage,
2367 .writepages = cifs_writepages,
2368 .write_begin = cifs_write_begin,
2369 .write_end = cifs_write_end,
2370 .set_page_dirty = __set_page_dirty_nobuffers,
2371 /* .sync_page = cifs_sync_page, */
2372 /* .direct_IO = */
2376 * cifs_readpages requires the server to support a buffer large enough to
2377 * contain the header plus one complete page of data. Otherwise, we need
2378 * to leave cifs_readpages out of the address space operations.
2380 const struct address_space_operations cifs_addr_ops_smallbuf = {
2381 .readpage = cifs_readpage,
2382 .writepage = cifs_writepage,
2383 .writepages = cifs_writepages,
2384 .write_begin = cifs_write_begin,
2385 .write_end = cifs_write_end,
2386 .set_page_dirty = __set_page_dirty_nobuffers,
2387 /* .sync_page = cifs_sync_page, */
2388 /* .direct_IO = */