x86/xen: resume timer irqs early
[linux/fpc-iii.git] / fs / cifs / file.c
blob643a18491bed6cded374c61bf707cbcc94dc216e
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 <linux/swap.h>
36 #include <asm/div64.h>
37 #include "cifsfs.h"
38 #include "cifspdu.h"
39 #include "cifsglob.h"
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
44 #include "fscache.h"
47 static inline int cifs_convert_flags(unsigned int flags)
49 if ((flags & O_ACCMODE) == O_RDONLY)
50 return GENERIC_READ;
51 else if ((flags & O_ACCMODE) == O_WRONLY)
52 return GENERIC_WRITE;
53 else if ((flags & O_ACCMODE) == O_RDWR) {
54 /* GENERIC_ALL is too much permission to request
55 can cause unnecessary access denied on create */
56 /* return GENERIC_ALL; */
57 return (GENERIC_READ | GENERIC_WRITE);
60 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
61 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
62 FILE_READ_DATA);
65 static u32 cifs_posix_convert_flags(unsigned int flags)
67 u32 posix_flags = 0;
69 if ((flags & O_ACCMODE) == O_RDONLY)
70 posix_flags = SMB_O_RDONLY;
71 else if ((flags & O_ACCMODE) == O_WRONLY)
72 posix_flags = SMB_O_WRONLY;
73 else if ((flags & O_ACCMODE) == O_RDWR)
74 posix_flags = SMB_O_RDWR;
76 if (flags & O_CREAT) {
77 posix_flags |= SMB_O_CREAT;
78 if (flags & O_EXCL)
79 posix_flags |= SMB_O_EXCL;
80 } else if (flags & O_EXCL)
81 cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
82 current->comm, current->tgid);
84 if (flags & O_TRUNC)
85 posix_flags |= SMB_O_TRUNC;
86 /* be safe and imply O_SYNC for O_DSYNC */
87 if (flags & O_DSYNC)
88 posix_flags |= SMB_O_SYNC;
89 if (flags & O_DIRECTORY)
90 posix_flags |= SMB_O_DIRECTORY;
91 if (flags & O_NOFOLLOW)
92 posix_flags |= SMB_O_NOFOLLOW;
93 if (flags & O_DIRECT)
94 posix_flags |= SMB_O_DIRECT;
96 return posix_flags;
99 static inline int cifs_get_disposition(unsigned int flags)
101 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
102 return FILE_CREATE;
103 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
104 return FILE_OVERWRITE_IF;
105 else if ((flags & O_CREAT) == O_CREAT)
106 return FILE_OPEN_IF;
107 else if ((flags & O_TRUNC) == O_TRUNC)
108 return FILE_OVERWRITE;
109 else
110 return FILE_OPEN;
113 int cifs_posix_open(char *full_path, struct inode **pinode,
114 struct super_block *sb, int mode, unsigned int f_flags,
115 __u32 *poplock, __u16 *pnetfid, unsigned int xid)
117 int rc;
118 FILE_UNIX_BASIC_INFO *presp_data;
119 __u32 posix_flags = 0;
120 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
121 struct cifs_fattr fattr;
122 struct tcon_link *tlink;
123 struct cifs_tcon *tcon;
125 cifs_dbg(FYI, "posix open %s\n", full_path);
127 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
128 if (presp_data == NULL)
129 return -ENOMEM;
131 tlink = cifs_sb_tlink(cifs_sb);
132 if (IS_ERR(tlink)) {
133 rc = PTR_ERR(tlink);
134 goto posix_open_ret;
137 tcon = tlink_tcon(tlink);
138 mode &= ~current_umask();
140 posix_flags = cifs_posix_convert_flags(f_flags);
141 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
142 poplock, full_path, cifs_sb->local_nls,
143 cifs_sb->mnt_cifs_flags &
144 CIFS_MOUNT_MAP_SPECIAL_CHR);
145 cifs_put_tlink(tlink);
147 if (rc)
148 goto posix_open_ret;
150 if (presp_data->Type == cpu_to_le32(-1))
151 goto posix_open_ret; /* open ok, caller does qpathinfo */
153 if (!pinode)
154 goto posix_open_ret; /* caller does not need info */
156 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
158 /* get new inode and set it up */
159 if (*pinode == NULL) {
160 cifs_fill_uniqueid(sb, &fattr);
161 *pinode = cifs_iget(sb, &fattr);
162 if (!*pinode) {
163 rc = -ENOMEM;
164 goto posix_open_ret;
166 } else {
167 cifs_fattr_to_inode(*pinode, &fattr);
170 posix_open_ret:
171 kfree(presp_data);
172 return rc;
175 static int
176 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
177 struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
178 struct cifs_fid *fid, unsigned int xid)
180 int rc;
181 int desired_access;
182 int disposition;
183 int create_options = CREATE_NOT_DIR;
184 FILE_ALL_INFO *buf;
185 struct TCP_Server_Info *server = tcon->ses->server;
186 struct cifs_open_parms oparms;
188 if (!server->ops->open)
189 return -ENOSYS;
191 desired_access = cifs_convert_flags(f_flags);
193 /*********************************************************************
194 * open flag mapping table:
196 * POSIX Flag CIFS Disposition
197 * ---------- ----------------
198 * O_CREAT FILE_OPEN_IF
199 * O_CREAT | O_EXCL FILE_CREATE
200 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
201 * O_TRUNC FILE_OVERWRITE
202 * none of the above FILE_OPEN
204 * Note that there is not a direct match between disposition
205 * FILE_SUPERSEDE (ie create whether or not file exists although
206 * O_CREAT | O_TRUNC is similar but truncates the existing
207 * file rather than creating a new file as FILE_SUPERSEDE does
208 * (which uses the attributes / metadata passed in on open call)
210 *? O_SYNC is a reasonable match to CIFS writethrough flag
211 *? and the read write flags match reasonably. O_LARGEFILE
212 *? is irrelevant because largefile support is always used
213 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
214 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
215 *********************************************************************/
217 disposition = cifs_get_disposition(f_flags);
219 /* BB pass O_SYNC flag through on file attributes .. BB */
221 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
222 if (!buf)
223 return -ENOMEM;
225 if (backup_cred(cifs_sb))
226 create_options |= CREATE_OPEN_BACKUP_INTENT;
228 oparms.tcon = tcon;
229 oparms.cifs_sb = cifs_sb;
230 oparms.desired_access = desired_access;
231 oparms.create_options = create_options;
232 oparms.disposition = disposition;
233 oparms.path = full_path;
234 oparms.fid = fid;
235 oparms.reconnect = false;
237 rc = server->ops->open(xid, &oparms, oplock, buf);
239 if (rc)
240 goto out;
242 if (tcon->unix_ext)
243 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
244 xid);
245 else
246 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
247 xid, &fid->netfid);
249 out:
250 kfree(buf);
251 return rc;
254 static bool
255 cifs_has_mand_locks(struct cifsInodeInfo *cinode)
257 struct cifs_fid_locks *cur;
258 bool has_locks = false;
260 down_read(&cinode->lock_sem);
261 list_for_each_entry(cur, &cinode->llist, llist) {
262 if (!list_empty(&cur->locks)) {
263 has_locks = true;
264 break;
267 up_read(&cinode->lock_sem);
268 return has_locks;
271 struct cifsFileInfo *
272 cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
273 struct tcon_link *tlink, __u32 oplock)
275 struct dentry *dentry = file->f_path.dentry;
276 struct inode *inode = dentry->d_inode;
277 struct cifsInodeInfo *cinode = CIFS_I(inode);
278 struct cifsFileInfo *cfile;
279 struct cifs_fid_locks *fdlocks;
280 struct cifs_tcon *tcon = tlink_tcon(tlink);
281 struct TCP_Server_Info *server = tcon->ses->server;
283 cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
284 if (cfile == NULL)
285 return cfile;
287 fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
288 if (!fdlocks) {
289 kfree(cfile);
290 return NULL;
293 INIT_LIST_HEAD(&fdlocks->locks);
294 fdlocks->cfile = cfile;
295 cfile->llist = fdlocks;
296 down_write(&cinode->lock_sem);
297 list_add(&fdlocks->llist, &cinode->llist);
298 up_write(&cinode->lock_sem);
300 cfile->count = 1;
301 cfile->pid = current->tgid;
302 cfile->uid = current_fsuid();
303 cfile->dentry = dget(dentry);
304 cfile->f_flags = file->f_flags;
305 cfile->invalidHandle = false;
306 cfile->tlink = cifs_get_tlink(tlink);
307 INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
308 mutex_init(&cfile->fh_mutex);
310 cifs_sb_active(inode->i_sb);
313 * If the server returned a read oplock and we have mandatory brlocks,
314 * set oplock level to None.
316 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
317 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
318 oplock = 0;
321 spin_lock(&cifs_file_list_lock);
322 if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
323 oplock = fid->pending_open->oplock;
324 list_del(&fid->pending_open->olist);
326 fid->purge_cache = false;
327 server->ops->set_fid(cfile, fid, oplock);
329 list_add(&cfile->tlist, &tcon->openFileList);
330 /* if readable file instance put first in list*/
331 if (file->f_mode & FMODE_READ)
332 list_add(&cfile->flist, &cinode->openFileList);
333 else
334 list_add_tail(&cfile->flist, &cinode->openFileList);
335 spin_unlock(&cifs_file_list_lock);
337 if (fid->purge_cache)
338 cifs_invalidate_mapping(inode);
340 file->private_data = cfile;
341 return cfile;
344 struct cifsFileInfo *
345 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
347 spin_lock(&cifs_file_list_lock);
348 cifsFileInfo_get_locked(cifs_file);
349 spin_unlock(&cifs_file_list_lock);
350 return cifs_file;
354 * Release a reference on the file private data. This may involve closing
355 * the filehandle out on the server. Must be called without holding
356 * cifs_file_list_lock.
358 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
360 struct inode *inode = cifs_file->dentry->d_inode;
361 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
362 struct TCP_Server_Info *server = tcon->ses->server;
363 struct cifsInodeInfo *cifsi = CIFS_I(inode);
364 struct super_block *sb = inode->i_sb;
365 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
366 struct cifsLockInfo *li, *tmp;
367 struct cifs_fid fid;
368 struct cifs_pending_open open;
370 spin_lock(&cifs_file_list_lock);
371 if (--cifs_file->count > 0) {
372 spin_unlock(&cifs_file_list_lock);
373 return;
376 if (server->ops->get_lease_key)
377 server->ops->get_lease_key(inode, &fid);
379 /* store open in pending opens to make sure we don't miss lease break */
380 cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
382 /* remove it from the lists */
383 list_del(&cifs_file->flist);
384 list_del(&cifs_file->tlist);
386 if (list_empty(&cifsi->openFileList)) {
387 cifs_dbg(FYI, "closing last open instance for inode %p\n",
388 cifs_file->dentry->d_inode);
390 * In strict cache mode we need invalidate mapping on the last
391 * close because it may cause a error when we open this file
392 * again and get at least level II oplock.
394 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
395 CIFS_I(inode)->invalid_mapping = true;
396 cifs_set_oplock_level(cifsi, 0);
398 spin_unlock(&cifs_file_list_lock);
400 cancel_work_sync(&cifs_file->oplock_break);
402 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
403 struct TCP_Server_Info *server = tcon->ses->server;
404 unsigned int xid;
406 xid = get_xid();
407 if (server->ops->close)
408 server->ops->close(xid, tcon, &cifs_file->fid);
409 _free_xid(xid);
412 cifs_del_pending_open(&open);
415 * Delete any outstanding lock records. We'll lose them when the file
416 * is closed anyway.
418 down_write(&cifsi->lock_sem);
419 list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
420 list_del(&li->llist);
421 cifs_del_lock_waiters(li);
422 kfree(li);
424 list_del(&cifs_file->llist->llist);
425 kfree(cifs_file->llist);
426 up_write(&cifsi->lock_sem);
428 cifs_put_tlink(cifs_file->tlink);
429 dput(cifs_file->dentry);
430 cifs_sb_deactive(sb);
431 kfree(cifs_file);
434 int cifs_open(struct inode *inode, struct file *file)
437 int rc = -EACCES;
438 unsigned int xid;
439 __u32 oplock;
440 struct cifs_sb_info *cifs_sb;
441 struct TCP_Server_Info *server;
442 struct cifs_tcon *tcon;
443 struct tcon_link *tlink;
444 struct cifsFileInfo *cfile = NULL;
445 char *full_path = NULL;
446 bool posix_open_ok = false;
447 struct cifs_fid fid;
448 struct cifs_pending_open open;
450 xid = get_xid();
452 cifs_sb = CIFS_SB(inode->i_sb);
453 tlink = cifs_sb_tlink(cifs_sb);
454 if (IS_ERR(tlink)) {
455 free_xid(xid);
456 return PTR_ERR(tlink);
458 tcon = tlink_tcon(tlink);
459 server = tcon->ses->server;
461 full_path = build_path_from_dentry(file->f_path.dentry);
462 if (full_path == NULL) {
463 rc = -ENOMEM;
464 goto out;
467 cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
468 inode, file->f_flags, full_path);
470 if (server->oplocks)
471 oplock = REQ_OPLOCK;
472 else
473 oplock = 0;
475 if (!tcon->broken_posix_open && tcon->unix_ext &&
476 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
477 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
478 /* can not refresh inode info since size could be stale */
479 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
480 cifs_sb->mnt_file_mode /* ignored */,
481 file->f_flags, &oplock, &fid.netfid, xid);
482 if (rc == 0) {
483 cifs_dbg(FYI, "posix open succeeded\n");
484 posix_open_ok = true;
485 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
486 if (tcon->ses->serverNOS)
487 cifs_dbg(VFS, "server %s of type %s returned unexpected error on SMB posix open, disabling posix open support. Check if server update available.\n",
488 tcon->ses->serverName,
489 tcon->ses->serverNOS);
490 tcon->broken_posix_open = true;
491 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
492 (rc != -EOPNOTSUPP)) /* path not found or net err */
493 goto out;
495 * Else fallthrough to retry open the old way on network i/o
496 * or DFS errors.
500 if (server->ops->get_lease_key)
501 server->ops->get_lease_key(inode, &fid);
503 cifs_add_pending_open(&fid, tlink, &open);
505 if (!posix_open_ok) {
506 if (server->ops->get_lease_key)
507 server->ops->get_lease_key(inode, &fid);
509 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
510 file->f_flags, &oplock, &fid, xid);
511 if (rc) {
512 cifs_del_pending_open(&open);
513 goto out;
517 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
518 if (cfile == NULL) {
519 if (server->ops->close)
520 server->ops->close(xid, tcon, &fid);
521 cifs_del_pending_open(&open);
522 rc = -ENOMEM;
523 goto out;
526 cifs_fscache_set_inode_cookie(inode, file);
528 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
530 * Time to set mode which we can not set earlier due to
531 * problems creating new read-only files.
533 struct cifs_unix_set_info_args args = {
534 .mode = inode->i_mode,
535 .uid = INVALID_UID, /* no change */
536 .gid = INVALID_GID, /* no change */
537 .ctime = NO_CHANGE_64,
538 .atime = NO_CHANGE_64,
539 .mtime = NO_CHANGE_64,
540 .device = 0,
542 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
543 cfile->pid);
546 out:
547 kfree(full_path);
548 free_xid(xid);
549 cifs_put_tlink(tlink);
550 return rc;
553 static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
556 * Try to reacquire byte range locks that were released when session
557 * to server was lost.
559 static int
560 cifs_relock_file(struct cifsFileInfo *cfile)
562 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
563 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
564 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
565 int rc = 0;
567 down_read(&cinode->lock_sem);
568 if (cinode->can_cache_brlcks) {
569 /* can cache locks - no need to relock */
570 up_read(&cinode->lock_sem);
571 return rc;
574 if (cap_unix(tcon->ses) &&
575 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
576 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
577 rc = cifs_push_posix_locks(cfile);
578 else
579 rc = tcon->ses->server->ops->push_mand_locks(cfile);
581 up_read(&cinode->lock_sem);
582 return rc;
585 static int
586 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
588 int rc = -EACCES;
589 unsigned int xid;
590 __u32 oplock;
591 struct cifs_sb_info *cifs_sb;
592 struct cifs_tcon *tcon;
593 struct TCP_Server_Info *server;
594 struct cifsInodeInfo *cinode;
595 struct inode *inode;
596 char *full_path = NULL;
597 int desired_access;
598 int disposition = FILE_OPEN;
599 int create_options = CREATE_NOT_DIR;
600 struct cifs_open_parms oparms;
602 xid = get_xid();
603 mutex_lock(&cfile->fh_mutex);
604 if (!cfile->invalidHandle) {
605 mutex_unlock(&cfile->fh_mutex);
606 rc = 0;
607 free_xid(xid);
608 return rc;
611 inode = cfile->dentry->d_inode;
612 cifs_sb = CIFS_SB(inode->i_sb);
613 tcon = tlink_tcon(cfile->tlink);
614 server = tcon->ses->server;
617 * Can not grab rename sem here because various ops, including those
618 * that already have the rename sem can end up causing writepage to get
619 * called and if the server was down that means we end up here, and we
620 * can never tell if the caller already has the rename_sem.
622 full_path = build_path_from_dentry(cfile->dentry);
623 if (full_path == NULL) {
624 rc = -ENOMEM;
625 mutex_unlock(&cfile->fh_mutex);
626 free_xid(xid);
627 return rc;
630 cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
631 inode, cfile->f_flags, full_path);
633 if (tcon->ses->server->oplocks)
634 oplock = REQ_OPLOCK;
635 else
636 oplock = 0;
638 if (tcon->unix_ext && cap_unix(tcon->ses) &&
639 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
640 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
642 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
643 * original open. Must mask them off for a reopen.
645 unsigned int oflags = cfile->f_flags &
646 ~(O_CREAT | O_EXCL | O_TRUNC);
648 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
649 cifs_sb->mnt_file_mode /* ignored */,
650 oflags, &oplock, &cfile->fid.netfid, xid);
651 if (rc == 0) {
652 cifs_dbg(FYI, "posix reopen succeeded\n");
653 oparms.reconnect = true;
654 goto reopen_success;
657 * fallthrough to retry open the old way on errors, especially
658 * in the reconnect path it is important to retry hard
662 desired_access = cifs_convert_flags(cfile->f_flags);
664 if (backup_cred(cifs_sb))
665 create_options |= CREATE_OPEN_BACKUP_INTENT;
667 if (server->ops->get_lease_key)
668 server->ops->get_lease_key(inode, &cfile->fid);
670 oparms.tcon = tcon;
671 oparms.cifs_sb = cifs_sb;
672 oparms.desired_access = desired_access;
673 oparms.create_options = create_options;
674 oparms.disposition = disposition;
675 oparms.path = full_path;
676 oparms.fid = &cfile->fid;
677 oparms.reconnect = true;
680 * Can not refresh inode by passing in file_info buf to be returned by
681 * CIFSSMBOpen and then calling get_inode_info with returned buf since
682 * file might have write behind data that needs to be flushed and server
683 * version of file size can be stale. If we knew for sure that inode was
684 * not dirty locally we could do this.
686 rc = server->ops->open(xid, &oparms, &oplock, NULL);
687 if (rc == -ENOENT && oparms.reconnect == false) {
688 /* durable handle timeout is expired - open the file again */
689 rc = server->ops->open(xid, &oparms, &oplock, NULL);
690 /* indicate that we need to relock the file */
691 oparms.reconnect = true;
694 if (rc) {
695 mutex_unlock(&cfile->fh_mutex);
696 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
697 cifs_dbg(FYI, "oplock: %d\n", oplock);
698 goto reopen_error_exit;
701 reopen_success:
702 cfile->invalidHandle = false;
703 mutex_unlock(&cfile->fh_mutex);
704 cinode = CIFS_I(inode);
706 if (can_flush) {
707 rc = filemap_write_and_wait(inode->i_mapping);
708 mapping_set_error(inode->i_mapping, rc);
710 if (tcon->unix_ext)
711 rc = cifs_get_inode_info_unix(&inode, full_path,
712 inode->i_sb, xid);
713 else
714 rc = cifs_get_inode_info(&inode, full_path, NULL,
715 inode->i_sb, xid, NULL);
718 * Else we are writing out data to server already and could deadlock if
719 * we tried to flush data, and since we do not know if we have data that
720 * would invalidate the current end of file on the server we can not go
721 * to the server to get the new inode info.
724 server->ops->set_fid(cfile, &cfile->fid, oplock);
725 if (oparms.reconnect)
726 cifs_relock_file(cfile);
728 reopen_error_exit:
729 kfree(full_path);
730 free_xid(xid);
731 return rc;
734 int cifs_close(struct inode *inode, struct file *file)
736 if (file->private_data != NULL) {
737 cifsFileInfo_put(file->private_data);
738 file->private_data = NULL;
741 /* return code from the ->release op is always ignored */
742 return 0;
745 int cifs_closedir(struct inode *inode, struct file *file)
747 int rc = 0;
748 unsigned int xid;
749 struct cifsFileInfo *cfile = file->private_data;
750 struct cifs_tcon *tcon;
751 struct TCP_Server_Info *server;
752 char *buf;
754 cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
756 if (cfile == NULL)
757 return rc;
759 xid = get_xid();
760 tcon = tlink_tcon(cfile->tlink);
761 server = tcon->ses->server;
763 cifs_dbg(FYI, "Freeing private data in close dir\n");
764 spin_lock(&cifs_file_list_lock);
765 if (!cfile->srch_inf.endOfSearch && !cfile->invalidHandle) {
766 cfile->invalidHandle = true;
767 spin_unlock(&cifs_file_list_lock);
768 if (server->ops->close_dir)
769 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
770 else
771 rc = -ENOSYS;
772 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
773 /* not much we can do if it fails anyway, ignore rc */
774 rc = 0;
775 } else
776 spin_unlock(&cifs_file_list_lock);
778 buf = cfile->srch_inf.ntwrk_buf_start;
779 if (buf) {
780 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
781 cfile->srch_inf.ntwrk_buf_start = NULL;
782 if (cfile->srch_inf.smallBuf)
783 cifs_small_buf_release(buf);
784 else
785 cifs_buf_release(buf);
788 cifs_put_tlink(cfile->tlink);
789 kfree(file->private_data);
790 file->private_data = NULL;
791 /* BB can we lock the filestruct while this is going on? */
792 free_xid(xid);
793 return rc;
796 static struct cifsLockInfo *
797 cifs_lock_init(__u64 offset, __u64 length, __u8 type)
799 struct cifsLockInfo *lock =
800 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
801 if (!lock)
802 return lock;
803 lock->offset = offset;
804 lock->length = length;
805 lock->type = type;
806 lock->pid = current->tgid;
807 INIT_LIST_HEAD(&lock->blist);
808 init_waitqueue_head(&lock->block_q);
809 return lock;
812 void
813 cifs_del_lock_waiters(struct cifsLockInfo *lock)
815 struct cifsLockInfo *li, *tmp;
816 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
817 list_del_init(&li->blist);
818 wake_up(&li->block_q);
822 #define CIFS_LOCK_OP 0
823 #define CIFS_READ_OP 1
824 #define CIFS_WRITE_OP 2
826 /* @rw_check : 0 - no op, 1 - read, 2 - write */
827 static bool
828 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
829 __u64 length, __u8 type, struct cifsFileInfo *cfile,
830 struct cifsLockInfo **conf_lock, int rw_check)
832 struct cifsLockInfo *li;
833 struct cifsFileInfo *cur_cfile = fdlocks->cfile;
834 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
836 list_for_each_entry(li, &fdlocks->locks, llist) {
837 if (offset + length <= li->offset ||
838 offset >= li->offset + li->length)
839 continue;
840 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
841 server->ops->compare_fids(cfile, cur_cfile)) {
842 /* shared lock prevents write op through the same fid */
843 if (!(li->type & server->vals->shared_lock_type) ||
844 rw_check != CIFS_WRITE_OP)
845 continue;
847 if ((type & server->vals->shared_lock_type) &&
848 ((server->ops->compare_fids(cfile, cur_cfile) &&
849 current->tgid == li->pid) || type == li->type))
850 continue;
851 if (conf_lock)
852 *conf_lock = li;
853 return true;
855 return false;
858 bool
859 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
860 __u8 type, struct cifsLockInfo **conf_lock,
861 int rw_check)
863 bool rc = false;
864 struct cifs_fid_locks *cur;
865 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
867 list_for_each_entry(cur, &cinode->llist, llist) {
868 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
869 cfile, conf_lock, rw_check);
870 if (rc)
871 break;
874 return rc;
878 * Check if there is another lock that prevents us to set the lock (mandatory
879 * style). If such a lock exists, update the flock structure with its
880 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
881 * or leave it the same if we can't. Returns 0 if we don't need to request to
882 * the server or 1 otherwise.
884 static int
885 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
886 __u8 type, struct file_lock *flock)
888 int rc = 0;
889 struct cifsLockInfo *conf_lock;
890 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
891 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
892 bool exist;
894 down_read(&cinode->lock_sem);
896 exist = cifs_find_lock_conflict(cfile, offset, length, type,
897 &conf_lock, CIFS_LOCK_OP);
898 if (exist) {
899 flock->fl_start = conf_lock->offset;
900 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
901 flock->fl_pid = conf_lock->pid;
902 if (conf_lock->type & server->vals->shared_lock_type)
903 flock->fl_type = F_RDLCK;
904 else
905 flock->fl_type = F_WRLCK;
906 } else if (!cinode->can_cache_brlcks)
907 rc = 1;
908 else
909 flock->fl_type = F_UNLCK;
911 up_read(&cinode->lock_sem);
912 return rc;
915 static void
916 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
918 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
919 down_write(&cinode->lock_sem);
920 list_add_tail(&lock->llist, &cfile->llist->locks);
921 up_write(&cinode->lock_sem);
925 * Set the byte-range lock (mandatory style). Returns:
926 * 1) 0, if we set the lock and don't need to request to the server;
927 * 2) 1, if no locks prevent us but we need to request to the server;
928 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
930 static int
931 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
932 bool wait)
934 struct cifsLockInfo *conf_lock;
935 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
936 bool exist;
937 int rc = 0;
939 try_again:
940 exist = false;
941 down_write(&cinode->lock_sem);
943 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
944 lock->type, &conf_lock, CIFS_LOCK_OP);
945 if (!exist && cinode->can_cache_brlcks) {
946 list_add_tail(&lock->llist, &cfile->llist->locks);
947 up_write(&cinode->lock_sem);
948 return rc;
951 if (!exist)
952 rc = 1;
953 else if (!wait)
954 rc = -EACCES;
955 else {
956 list_add_tail(&lock->blist, &conf_lock->blist);
957 up_write(&cinode->lock_sem);
958 rc = wait_event_interruptible(lock->block_q,
959 (lock->blist.prev == &lock->blist) &&
960 (lock->blist.next == &lock->blist));
961 if (!rc)
962 goto try_again;
963 down_write(&cinode->lock_sem);
964 list_del_init(&lock->blist);
967 up_write(&cinode->lock_sem);
968 return rc;
972 * Check if there is another lock that prevents us to set the lock (posix
973 * style). If such a lock exists, update the flock structure with its
974 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
975 * or leave it the same if we can't. Returns 0 if we don't need to request to
976 * the server or 1 otherwise.
978 static int
979 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
981 int rc = 0;
982 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
983 unsigned char saved_type = flock->fl_type;
985 if ((flock->fl_flags & FL_POSIX) == 0)
986 return 1;
988 down_read(&cinode->lock_sem);
989 posix_test_lock(file, flock);
991 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
992 flock->fl_type = saved_type;
993 rc = 1;
996 up_read(&cinode->lock_sem);
997 return rc;
1001 * Set the byte-range lock (posix style). Returns:
1002 * 1) 0, if we set the lock and don't need to request to the server;
1003 * 2) 1, if we need to request to the server;
1004 * 3) <0, if the error occurs while setting the lock.
1006 static int
1007 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1009 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1010 int rc = 1;
1012 if ((flock->fl_flags & FL_POSIX) == 0)
1013 return rc;
1015 try_again:
1016 down_write(&cinode->lock_sem);
1017 if (!cinode->can_cache_brlcks) {
1018 up_write(&cinode->lock_sem);
1019 return rc;
1022 rc = posix_lock_file(file, flock, NULL);
1023 up_write(&cinode->lock_sem);
1024 if (rc == FILE_LOCK_DEFERRED) {
1025 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
1026 if (!rc)
1027 goto try_again;
1028 posix_unblock_lock(flock);
1030 return rc;
1034 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1036 unsigned int xid;
1037 int rc = 0, stored_rc;
1038 struct cifsLockInfo *li, *tmp;
1039 struct cifs_tcon *tcon;
1040 unsigned int num, max_num, max_buf;
1041 LOCKING_ANDX_RANGE *buf, *cur;
1042 int types[] = {LOCKING_ANDX_LARGE_FILES,
1043 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1044 int i;
1046 xid = get_xid();
1047 tcon = tlink_tcon(cfile->tlink);
1050 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1051 * and check it for zero before using.
1053 max_buf = tcon->ses->server->maxBuf;
1054 if (!max_buf) {
1055 free_xid(xid);
1056 return -EINVAL;
1059 max_num = (max_buf - sizeof(struct smb_hdr)) /
1060 sizeof(LOCKING_ANDX_RANGE);
1061 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1062 if (!buf) {
1063 free_xid(xid);
1064 return -ENOMEM;
1067 for (i = 0; i < 2; i++) {
1068 cur = buf;
1069 num = 0;
1070 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1071 if (li->type != types[i])
1072 continue;
1073 cur->Pid = cpu_to_le16(li->pid);
1074 cur->LengthLow = cpu_to_le32((u32)li->length);
1075 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1076 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1077 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1078 if (++num == max_num) {
1079 stored_rc = cifs_lockv(xid, tcon,
1080 cfile->fid.netfid,
1081 (__u8)li->type, 0, num,
1082 buf);
1083 if (stored_rc)
1084 rc = stored_rc;
1085 cur = buf;
1086 num = 0;
1087 } else
1088 cur++;
1091 if (num) {
1092 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1093 (__u8)types[i], 0, num, buf);
1094 if (stored_rc)
1095 rc = stored_rc;
1099 kfree(buf);
1100 free_xid(xid);
1101 return rc;
1104 /* copied from fs/locks.c with a name change */
1105 #define cifs_for_each_lock(inode, lockp) \
1106 for (lockp = &inode->i_flock; *lockp != NULL; \
1107 lockp = &(*lockp)->fl_next)
1109 struct lock_to_push {
1110 struct list_head llist;
1111 __u64 offset;
1112 __u64 length;
1113 __u32 pid;
1114 __u16 netfid;
1115 __u8 type;
1118 static int
1119 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1121 struct inode *inode = cfile->dentry->d_inode;
1122 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1123 struct file_lock *flock, **before;
1124 unsigned int count = 0, i = 0;
1125 int rc = 0, xid, type;
1126 struct list_head locks_to_send, *el;
1127 struct lock_to_push *lck, *tmp;
1128 __u64 length;
1130 xid = get_xid();
1132 spin_lock(&inode->i_lock);
1133 cifs_for_each_lock(inode, before) {
1134 if ((*before)->fl_flags & FL_POSIX)
1135 count++;
1137 spin_unlock(&inode->i_lock);
1139 INIT_LIST_HEAD(&locks_to_send);
1142 * Allocating count locks is enough because no FL_POSIX locks can be
1143 * added to the list while we are holding cinode->lock_sem that
1144 * protects locking operations of this inode.
1146 for (; i < count; i++) {
1147 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1148 if (!lck) {
1149 rc = -ENOMEM;
1150 goto err_out;
1152 list_add_tail(&lck->llist, &locks_to_send);
1155 el = locks_to_send.next;
1156 spin_lock(&inode->i_lock);
1157 cifs_for_each_lock(inode, before) {
1158 flock = *before;
1159 if ((flock->fl_flags & FL_POSIX) == 0)
1160 continue;
1161 if (el == &locks_to_send) {
1163 * The list ended. We don't have enough allocated
1164 * structures - something is really wrong.
1166 cifs_dbg(VFS, "Can't push all brlocks!\n");
1167 break;
1169 length = 1 + flock->fl_end - flock->fl_start;
1170 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1171 type = CIFS_RDLCK;
1172 else
1173 type = CIFS_WRLCK;
1174 lck = list_entry(el, struct lock_to_push, llist);
1175 lck->pid = flock->fl_pid;
1176 lck->netfid = cfile->fid.netfid;
1177 lck->length = length;
1178 lck->type = type;
1179 lck->offset = flock->fl_start;
1180 el = el->next;
1182 spin_unlock(&inode->i_lock);
1184 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1185 int stored_rc;
1187 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1188 lck->offset, lck->length, NULL,
1189 lck->type, 0);
1190 if (stored_rc)
1191 rc = stored_rc;
1192 list_del(&lck->llist);
1193 kfree(lck);
1196 out:
1197 free_xid(xid);
1198 return rc;
1199 err_out:
1200 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1201 list_del(&lck->llist);
1202 kfree(lck);
1204 goto out;
1207 static int
1208 cifs_push_locks(struct cifsFileInfo *cfile)
1210 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1211 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1212 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1213 int rc = 0;
1215 /* we are going to update can_cache_brlcks here - need a write access */
1216 down_write(&cinode->lock_sem);
1217 if (!cinode->can_cache_brlcks) {
1218 up_write(&cinode->lock_sem);
1219 return rc;
1222 if (cap_unix(tcon->ses) &&
1223 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1224 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1225 rc = cifs_push_posix_locks(cfile);
1226 else
1227 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1229 cinode->can_cache_brlcks = false;
1230 up_write(&cinode->lock_sem);
1231 return rc;
1234 static void
1235 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1236 bool *wait_flag, struct TCP_Server_Info *server)
1238 if (flock->fl_flags & FL_POSIX)
1239 cifs_dbg(FYI, "Posix\n");
1240 if (flock->fl_flags & FL_FLOCK)
1241 cifs_dbg(FYI, "Flock\n");
1242 if (flock->fl_flags & FL_SLEEP) {
1243 cifs_dbg(FYI, "Blocking lock\n");
1244 *wait_flag = true;
1246 if (flock->fl_flags & FL_ACCESS)
1247 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1248 if (flock->fl_flags & FL_LEASE)
1249 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1250 if (flock->fl_flags &
1251 (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1252 FL_ACCESS | FL_LEASE | FL_CLOSE)))
1253 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1255 *type = server->vals->large_lock_type;
1256 if (flock->fl_type == F_WRLCK) {
1257 cifs_dbg(FYI, "F_WRLCK\n");
1258 *type |= server->vals->exclusive_lock_type;
1259 *lock = 1;
1260 } else if (flock->fl_type == F_UNLCK) {
1261 cifs_dbg(FYI, "F_UNLCK\n");
1262 *type |= server->vals->unlock_lock_type;
1263 *unlock = 1;
1264 /* Check if unlock includes more than one lock range */
1265 } else if (flock->fl_type == F_RDLCK) {
1266 cifs_dbg(FYI, "F_RDLCK\n");
1267 *type |= server->vals->shared_lock_type;
1268 *lock = 1;
1269 } else if (flock->fl_type == F_EXLCK) {
1270 cifs_dbg(FYI, "F_EXLCK\n");
1271 *type |= server->vals->exclusive_lock_type;
1272 *lock = 1;
1273 } else if (flock->fl_type == F_SHLCK) {
1274 cifs_dbg(FYI, "F_SHLCK\n");
1275 *type |= server->vals->shared_lock_type;
1276 *lock = 1;
1277 } else
1278 cifs_dbg(FYI, "Unknown type of lock\n");
1281 static int
1282 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1283 bool wait_flag, bool posix_lck, unsigned int xid)
1285 int rc = 0;
1286 __u64 length = 1 + flock->fl_end - flock->fl_start;
1287 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1288 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1289 struct TCP_Server_Info *server = tcon->ses->server;
1290 __u16 netfid = cfile->fid.netfid;
1292 if (posix_lck) {
1293 int posix_lock_type;
1295 rc = cifs_posix_lock_test(file, flock);
1296 if (!rc)
1297 return rc;
1299 if (type & server->vals->shared_lock_type)
1300 posix_lock_type = CIFS_RDLCK;
1301 else
1302 posix_lock_type = CIFS_WRLCK;
1303 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1304 flock->fl_start, length, flock,
1305 posix_lock_type, wait_flag);
1306 return rc;
1309 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1310 if (!rc)
1311 return rc;
1313 /* BB we could chain these into one lock request BB */
1314 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1315 1, 0, false);
1316 if (rc == 0) {
1317 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1318 type, 0, 1, false);
1319 flock->fl_type = F_UNLCK;
1320 if (rc != 0)
1321 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1322 rc);
1323 return 0;
1326 if (type & server->vals->shared_lock_type) {
1327 flock->fl_type = F_WRLCK;
1328 return 0;
1331 type &= ~server->vals->exclusive_lock_type;
1333 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1334 type | server->vals->shared_lock_type,
1335 1, 0, false);
1336 if (rc == 0) {
1337 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1338 type | server->vals->shared_lock_type, 0, 1, false);
1339 flock->fl_type = F_RDLCK;
1340 if (rc != 0)
1341 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1342 rc);
1343 } else
1344 flock->fl_type = F_WRLCK;
1346 return 0;
1349 void
1350 cifs_move_llist(struct list_head *source, struct list_head *dest)
1352 struct list_head *li, *tmp;
1353 list_for_each_safe(li, tmp, source)
1354 list_move(li, dest);
1357 void
1358 cifs_free_llist(struct list_head *llist)
1360 struct cifsLockInfo *li, *tmp;
1361 list_for_each_entry_safe(li, tmp, llist, llist) {
1362 cifs_del_lock_waiters(li);
1363 list_del(&li->llist);
1364 kfree(li);
1369 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1370 unsigned int xid)
1372 int rc = 0, stored_rc;
1373 int types[] = {LOCKING_ANDX_LARGE_FILES,
1374 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1375 unsigned int i;
1376 unsigned int max_num, num, max_buf;
1377 LOCKING_ANDX_RANGE *buf, *cur;
1378 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1379 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1380 struct cifsLockInfo *li, *tmp;
1381 __u64 length = 1 + flock->fl_end - flock->fl_start;
1382 struct list_head tmp_llist;
1384 INIT_LIST_HEAD(&tmp_llist);
1387 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1388 * and check it for zero before using.
1390 max_buf = tcon->ses->server->maxBuf;
1391 if (!max_buf)
1392 return -EINVAL;
1394 max_num = (max_buf - sizeof(struct smb_hdr)) /
1395 sizeof(LOCKING_ANDX_RANGE);
1396 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1397 if (!buf)
1398 return -ENOMEM;
1400 down_write(&cinode->lock_sem);
1401 for (i = 0; i < 2; i++) {
1402 cur = buf;
1403 num = 0;
1404 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1405 if (flock->fl_start > li->offset ||
1406 (flock->fl_start + length) <
1407 (li->offset + li->length))
1408 continue;
1409 if (current->tgid != li->pid)
1410 continue;
1411 if (types[i] != li->type)
1412 continue;
1413 if (cinode->can_cache_brlcks) {
1415 * We can cache brlock requests - simply remove
1416 * a lock from the file's list.
1418 list_del(&li->llist);
1419 cifs_del_lock_waiters(li);
1420 kfree(li);
1421 continue;
1423 cur->Pid = cpu_to_le16(li->pid);
1424 cur->LengthLow = cpu_to_le32((u32)li->length);
1425 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1426 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1427 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1429 * We need to save a lock here to let us add it again to
1430 * the file's list if the unlock range request fails on
1431 * the server.
1433 list_move(&li->llist, &tmp_llist);
1434 if (++num == max_num) {
1435 stored_rc = cifs_lockv(xid, tcon,
1436 cfile->fid.netfid,
1437 li->type, num, 0, buf);
1438 if (stored_rc) {
1440 * We failed on the unlock range
1441 * request - add all locks from the tmp
1442 * list to the head of the file's list.
1444 cifs_move_llist(&tmp_llist,
1445 &cfile->llist->locks);
1446 rc = stored_rc;
1447 } else
1449 * The unlock range request succeed -
1450 * free the tmp list.
1452 cifs_free_llist(&tmp_llist);
1453 cur = buf;
1454 num = 0;
1455 } else
1456 cur++;
1458 if (num) {
1459 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1460 types[i], num, 0, buf);
1461 if (stored_rc) {
1462 cifs_move_llist(&tmp_llist,
1463 &cfile->llist->locks);
1464 rc = stored_rc;
1465 } else
1466 cifs_free_llist(&tmp_llist);
1470 up_write(&cinode->lock_sem);
1471 kfree(buf);
1472 return rc;
1475 static int
1476 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1477 bool wait_flag, bool posix_lck, int lock, int unlock,
1478 unsigned int xid)
1480 int rc = 0;
1481 __u64 length = 1 + flock->fl_end - flock->fl_start;
1482 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1483 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1484 struct TCP_Server_Info *server = tcon->ses->server;
1485 struct inode *inode = cfile->dentry->d_inode;
1487 if (posix_lck) {
1488 int posix_lock_type;
1490 rc = cifs_posix_lock_set(file, flock);
1491 if (!rc || rc < 0)
1492 return rc;
1494 if (type & server->vals->shared_lock_type)
1495 posix_lock_type = CIFS_RDLCK;
1496 else
1497 posix_lock_type = CIFS_WRLCK;
1499 if (unlock == 1)
1500 posix_lock_type = CIFS_UNLCK;
1502 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1503 current->tgid, flock->fl_start, length,
1504 NULL, posix_lock_type, wait_flag);
1505 goto out;
1508 if (lock) {
1509 struct cifsLockInfo *lock;
1511 lock = cifs_lock_init(flock->fl_start, length, type);
1512 if (!lock)
1513 return -ENOMEM;
1515 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1516 if (rc < 0) {
1517 kfree(lock);
1518 return rc;
1520 if (!rc)
1521 goto out;
1524 * Windows 7 server can delay breaking lease from read to None
1525 * if we set a byte-range lock on a file - break it explicitly
1526 * before sending the lock to the server to be sure the next
1527 * read won't conflict with non-overlapted locks due to
1528 * pagereading.
1530 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1531 CIFS_CACHE_READ(CIFS_I(inode))) {
1532 cifs_invalidate_mapping(inode);
1533 cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1534 inode);
1535 CIFS_I(inode)->oplock = 0;
1538 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1539 type, 1, 0, wait_flag);
1540 if (rc) {
1541 kfree(lock);
1542 return rc;
1545 cifs_lock_add(cfile, lock);
1546 } else if (unlock)
1547 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1549 out:
1550 if (flock->fl_flags & FL_POSIX)
1551 posix_lock_file_wait(file, flock);
1552 return rc;
1555 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1557 int rc, xid;
1558 int lock = 0, unlock = 0;
1559 bool wait_flag = false;
1560 bool posix_lck = false;
1561 struct cifs_sb_info *cifs_sb;
1562 struct cifs_tcon *tcon;
1563 struct cifsInodeInfo *cinode;
1564 struct cifsFileInfo *cfile;
1565 __u16 netfid;
1566 __u32 type;
1568 rc = -EACCES;
1569 xid = get_xid();
1571 cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1572 cmd, flock->fl_flags, flock->fl_type,
1573 flock->fl_start, flock->fl_end);
1575 cfile = (struct cifsFileInfo *)file->private_data;
1576 tcon = tlink_tcon(cfile->tlink);
1578 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1579 tcon->ses->server);
1581 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1582 netfid = cfile->fid.netfid;
1583 cinode = CIFS_I(file_inode(file));
1585 if (cap_unix(tcon->ses) &&
1586 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1587 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1588 posix_lck = true;
1590 * BB add code here to normalize offset and length to account for
1591 * negative length which we can not accept over the wire.
1593 if (IS_GETLK(cmd)) {
1594 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1595 free_xid(xid);
1596 return rc;
1599 if (!lock && !unlock) {
1601 * if no lock or unlock then nothing to do since we do not
1602 * know what it is
1604 free_xid(xid);
1605 return -EOPNOTSUPP;
1608 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1609 xid);
1610 free_xid(xid);
1611 return rc;
1615 * update the file size (if needed) after a write. Should be called with
1616 * the inode->i_lock held
1618 void
1619 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1620 unsigned int bytes_written)
1622 loff_t end_of_write = offset + bytes_written;
1624 if (end_of_write > cifsi->server_eof)
1625 cifsi->server_eof = end_of_write;
1628 static ssize_t
1629 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1630 size_t write_size, loff_t *offset)
1632 int rc = 0;
1633 unsigned int bytes_written = 0;
1634 unsigned int total_written;
1635 struct cifs_sb_info *cifs_sb;
1636 struct cifs_tcon *tcon;
1637 struct TCP_Server_Info *server;
1638 unsigned int xid;
1639 struct dentry *dentry = open_file->dentry;
1640 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1641 struct cifs_io_parms io_parms;
1643 cifs_sb = CIFS_SB(dentry->d_sb);
1645 cifs_dbg(FYI, "write %zd bytes to offset %lld of %s\n",
1646 write_size, *offset, dentry->d_name.name);
1648 tcon = tlink_tcon(open_file->tlink);
1649 server = tcon->ses->server;
1651 if (!server->ops->sync_write)
1652 return -ENOSYS;
1654 xid = get_xid();
1656 for (total_written = 0; write_size > total_written;
1657 total_written += bytes_written) {
1658 rc = -EAGAIN;
1659 while (rc == -EAGAIN) {
1660 struct kvec iov[2];
1661 unsigned int len;
1663 if (open_file->invalidHandle) {
1664 /* we could deadlock if we called
1665 filemap_fdatawait from here so tell
1666 reopen_file not to flush data to
1667 server now */
1668 rc = cifs_reopen_file(open_file, false);
1669 if (rc != 0)
1670 break;
1673 len = min((size_t)cifs_sb->wsize,
1674 write_size - total_written);
1675 /* iov[0] is reserved for smb header */
1676 iov[1].iov_base = (char *)write_data + total_written;
1677 iov[1].iov_len = len;
1678 io_parms.pid = pid;
1679 io_parms.tcon = tcon;
1680 io_parms.offset = *offset;
1681 io_parms.length = len;
1682 rc = server->ops->sync_write(xid, open_file, &io_parms,
1683 &bytes_written, iov, 1);
1685 if (rc || (bytes_written == 0)) {
1686 if (total_written)
1687 break;
1688 else {
1689 free_xid(xid);
1690 return rc;
1692 } else {
1693 spin_lock(&dentry->d_inode->i_lock);
1694 cifs_update_eof(cifsi, *offset, bytes_written);
1695 spin_unlock(&dentry->d_inode->i_lock);
1696 *offset += bytes_written;
1700 cifs_stats_bytes_written(tcon, total_written);
1702 if (total_written > 0) {
1703 spin_lock(&dentry->d_inode->i_lock);
1704 if (*offset > dentry->d_inode->i_size)
1705 i_size_write(dentry->d_inode, *offset);
1706 spin_unlock(&dentry->d_inode->i_lock);
1708 mark_inode_dirty_sync(dentry->d_inode);
1709 free_xid(xid);
1710 return total_written;
1713 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1714 bool fsuid_only)
1716 struct cifsFileInfo *open_file = NULL;
1717 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1719 /* only filter by fsuid on multiuser mounts */
1720 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1721 fsuid_only = false;
1723 spin_lock(&cifs_file_list_lock);
1724 /* we could simply get the first_list_entry since write-only entries
1725 are always at the end of the list but since the first entry might
1726 have a close pending, we go through the whole list */
1727 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1728 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1729 continue;
1730 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1731 if (!open_file->invalidHandle) {
1732 /* found a good file */
1733 /* lock it so it will not be closed on us */
1734 cifsFileInfo_get_locked(open_file);
1735 spin_unlock(&cifs_file_list_lock);
1736 return open_file;
1737 } /* else might as well continue, and look for
1738 another, or simply have the caller reopen it
1739 again rather than trying to fix this handle */
1740 } else /* write only file */
1741 break; /* write only files are last so must be done */
1743 spin_unlock(&cifs_file_list_lock);
1744 return NULL;
1747 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1748 bool fsuid_only)
1750 struct cifsFileInfo *open_file, *inv_file = NULL;
1751 struct cifs_sb_info *cifs_sb;
1752 bool any_available = false;
1753 int rc;
1754 unsigned int refind = 0;
1756 /* Having a null inode here (because mapping->host was set to zero by
1757 the VFS or MM) should not happen but we had reports of on oops (due to
1758 it being zero) during stress testcases so we need to check for it */
1760 if (cifs_inode == NULL) {
1761 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1762 dump_stack();
1763 return NULL;
1766 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1768 /* only filter by fsuid on multiuser mounts */
1769 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1770 fsuid_only = false;
1772 spin_lock(&cifs_file_list_lock);
1773 refind_writable:
1774 if (refind > MAX_REOPEN_ATT) {
1775 spin_unlock(&cifs_file_list_lock);
1776 return NULL;
1778 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1779 if (!any_available && open_file->pid != current->tgid)
1780 continue;
1781 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1782 continue;
1783 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1784 if (!open_file->invalidHandle) {
1785 /* found a good writable file */
1786 cifsFileInfo_get_locked(open_file);
1787 spin_unlock(&cifs_file_list_lock);
1788 return open_file;
1789 } else {
1790 if (!inv_file)
1791 inv_file = open_file;
1795 /* couldn't find useable FH with same pid, try any available */
1796 if (!any_available) {
1797 any_available = true;
1798 goto refind_writable;
1801 if (inv_file) {
1802 any_available = false;
1803 cifsFileInfo_get_locked(inv_file);
1806 spin_unlock(&cifs_file_list_lock);
1808 if (inv_file) {
1809 rc = cifs_reopen_file(inv_file, false);
1810 if (!rc)
1811 return inv_file;
1812 else {
1813 spin_lock(&cifs_file_list_lock);
1814 list_move_tail(&inv_file->flist,
1815 &cifs_inode->openFileList);
1816 spin_unlock(&cifs_file_list_lock);
1817 cifsFileInfo_put(inv_file);
1818 spin_lock(&cifs_file_list_lock);
1819 ++refind;
1820 goto refind_writable;
1824 return NULL;
1827 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1829 struct address_space *mapping = page->mapping;
1830 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1831 char *write_data;
1832 int rc = -EFAULT;
1833 int bytes_written = 0;
1834 struct inode *inode;
1835 struct cifsFileInfo *open_file;
1837 if (!mapping || !mapping->host)
1838 return -EFAULT;
1840 inode = page->mapping->host;
1842 offset += (loff_t)from;
1843 write_data = kmap(page);
1844 write_data += from;
1846 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1847 kunmap(page);
1848 return -EIO;
1851 /* racing with truncate? */
1852 if (offset > mapping->host->i_size) {
1853 kunmap(page);
1854 return 0; /* don't care */
1857 /* check to make sure that we are not extending the file */
1858 if (mapping->host->i_size - offset < (loff_t)to)
1859 to = (unsigned)(mapping->host->i_size - offset);
1861 open_file = find_writable_file(CIFS_I(mapping->host), false);
1862 if (open_file) {
1863 bytes_written = cifs_write(open_file, open_file->pid,
1864 write_data, to - from, &offset);
1865 cifsFileInfo_put(open_file);
1866 /* Does mm or vfs already set times? */
1867 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1868 if ((bytes_written > 0) && (offset))
1869 rc = 0;
1870 else if (bytes_written < 0)
1871 rc = bytes_written;
1872 } else {
1873 cifs_dbg(FYI, "No writeable filehandles for inode\n");
1874 rc = -EIO;
1877 kunmap(page);
1878 return rc;
1881 static int cifs_writepages(struct address_space *mapping,
1882 struct writeback_control *wbc)
1884 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1885 bool done = false, scanned = false, range_whole = false;
1886 pgoff_t end, index;
1887 struct cifs_writedata *wdata;
1888 struct TCP_Server_Info *server;
1889 struct page *page;
1890 int rc = 0;
1893 * If wsize is smaller than the page cache size, default to writing
1894 * one page at a time via cifs_writepage
1896 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1897 return generic_writepages(mapping, wbc);
1899 if (wbc->range_cyclic) {
1900 index = mapping->writeback_index; /* Start from prev offset */
1901 end = -1;
1902 } else {
1903 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1904 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1905 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1906 range_whole = true;
1907 scanned = true;
1909 retry:
1910 while (!done && index <= end) {
1911 unsigned int i, nr_pages, found_pages;
1912 pgoff_t next = 0, tofind;
1913 struct page **pages;
1915 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1916 end - index) + 1;
1918 wdata = cifs_writedata_alloc((unsigned int)tofind,
1919 cifs_writev_complete);
1920 if (!wdata) {
1921 rc = -ENOMEM;
1922 break;
1926 * find_get_pages_tag seems to return a max of 256 on each
1927 * iteration, so we must call it several times in order to
1928 * fill the array or the wsize is effectively limited to
1929 * 256 * PAGE_CACHE_SIZE.
1931 found_pages = 0;
1932 pages = wdata->pages;
1933 do {
1934 nr_pages = find_get_pages_tag(mapping, &index,
1935 PAGECACHE_TAG_DIRTY,
1936 tofind, pages);
1937 found_pages += nr_pages;
1938 tofind -= nr_pages;
1939 pages += nr_pages;
1940 } while (nr_pages && tofind && index <= end);
1942 if (found_pages == 0) {
1943 kref_put(&wdata->refcount, cifs_writedata_release);
1944 break;
1947 nr_pages = 0;
1948 for (i = 0; i < found_pages; i++) {
1949 page = wdata->pages[i];
1951 * At this point we hold neither mapping->tree_lock nor
1952 * lock on the page itself: the page may be truncated or
1953 * invalidated (changing page->mapping to NULL), or even
1954 * swizzled back from swapper_space to tmpfs file
1955 * mapping
1958 if (nr_pages == 0)
1959 lock_page(page);
1960 else if (!trylock_page(page))
1961 break;
1963 if (unlikely(page->mapping != mapping)) {
1964 unlock_page(page);
1965 break;
1968 if (!wbc->range_cyclic && page->index > end) {
1969 done = true;
1970 unlock_page(page);
1971 break;
1974 if (next && (page->index != next)) {
1975 /* Not next consecutive page */
1976 unlock_page(page);
1977 break;
1980 if (wbc->sync_mode != WB_SYNC_NONE)
1981 wait_on_page_writeback(page);
1983 if (PageWriteback(page) ||
1984 !clear_page_dirty_for_io(page)) {
1985 unlock_page(page);
1986 break;
1990 * This actually clears the dirty bit in the radix tree.
1991 * See cifs_writepage() for more commentary.
1993 set_page_writeback(page);
1995 if (page_offset(page) >= i_size_read(mapping->host)) {
1996 done = true;
1997 unlock_page(page);
1998 end_page_writeback(page);
1999 break;
2002 wdata->pages[i] = page;
2003 next = page->index + 1;
2004 ++nr_pages;
2007 /* reset index to refind any pages skipped */
2008 if (nr_pages == 0)
2009 index = wdata->pages[0]->index + 1;
2011 /* put any pages we aren't going to use */
2012 for (i = nr_pages; i < found_pages; i++) {
2013 page_cache_release(wdata->pages[i]);
2014 wdata->pages[i] = NULL;
2017 /* nothing to write? */
2018 if (nr_pages == 0) {
2019 kref_put(&wdata->refcount, cifs_writedata_release);
2020 continue;
2023 wdata->sync_mode = wbc->sync_mode;
2024 wdata->nr_pages = nr_pages;
2025 wdata->offset = page_offset(wdata->pages[0]);
2026 wdata->pagesz = PAGE_CACHE_SIZE;
2027 wdata->tailsz =
2028 min(i_size_read(mapping->host) -
2029 page_offset(wdata->pages[nr_pages - 1]),
2030 (loff_t)PAGE_CACHE_SIZE);
2031 wdata->bytes = ((nr_pages - 1) * PAGE_CACHE_SIZE) +
2032 wdata->tailsz;
2034 do {
2035 if (wdata->cfile != NULL)
2036 cifsFileInfo_put(wdata->cfile);
2037 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
2038 false);
2039 if (!wdata->cfile) {
2040 cifs_dbg(VFS, "No writable handles for inode\n");
2041 rc = -EBADF;
2042 break;
2044 wdata->pid = wdata->cfile->pid;
2045 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2046 rc = server->ops->async_writev(wdata);
2047 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
2049 for (i = 0; i < nr_pages; ++i)
2050 unlock_page(wdata->pages[i]);
2052 /* send failure -- clean up the mess */
2053 if (rc != 0) {
2054 for (i = 0; i < nr_pages; ++i) {
2055 if (rc == -EAGAIN)
2056 redirty_page_for_writepage(wbc,
2057 wdata->pages[i]);
2058 else
2059 SetPageError(wdata->pages[i]);
2060 end_page_writeback(wdata->pages[i]);
2061 page_cache_release(wdata->pages[i]);
2063 if (rc != -EAGAIN)
2064 mapping_set_error(mapping, rc);
2066 kref_put(&wdata->refcount, cifs_writedata_release);
2068 wbc->nr_to_write -= nr_pages;
2069 if (wbc->nr_to_write <= 0)
2070 done = true;
2072 index = next;
2075 if (!scanned && !done) {
2077 * We hit the last page and there is more work to be done: wrap
2078 * back to the start of the file
2080 scanned = true;
2081 index = 0;
2082 goto retry;
2085 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2086 mapping->writeback_index = index;
2088 return rc;
2091 static int
2092 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2094 int rc;
2095 unsigned int xid;
2097 xid = get_xid();
2098 /* BB add check for wbc flags */
2099 page_cache_get(page);
2100 if (!PageUptodate(page))
2101 cifs_dbg(FYI, "ppw - page not up to date\n");
2104 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2106 * A writepage() implementation always needs to do either this,
2107 * or re-dirty the page with "redirty_page_for_writepage()" in
2108 * the case of a failure.
2110 * Just unlocking the page will cause the radix tree tag-bits
2111 * to fail to update with the state of the page correctly.
2113 set_page_writeback(page);
2114 retry_write:
2115 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
2116 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
2117 goto retry_write;
2118 else if (rc == -EAGAIN)
2119 redirty_page_for_writepage(wbc, page);
2120 else if (rc != 0)
2121 SetPageError(page);
2122 else
2123 SetPageUptodate(page);
2124 end_page_writeback(page);
2125 page_cache_release(page);
2126 free_xid(xid);
2127 return rc;
2130 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2132 int rc = cifs_writepage_locked(page, wbc);
2133 unlock_page(page);
2134 return rc;
2137 static int cifs_write_end(struct file *file, struct address_space *mapping,
2138 loff_t pos, unsigned len, unsigned copied,
2139 struct page *page, void *fsdata)
2141 int rc;
2142 struct inode *inode = mapping->host;
2143 struct cifsFileInfo *cfile = file->private_data;
2144 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2145 __u32 pid;
2147 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2148 pid = cfile->pid;
2149 else
2150 pid = current->tgid;
2152 cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2153 page, pos, copied);
2155 if (PageChecked(page)) {
2156 if (copied == len)
2157 SetPageUptodate(page);
2158 ClearPageChecked(page);
2159 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
2160 SetPageUptodate(page);
2162 if (!PageUptodate(page)) {
2163 char *page_data;
2164 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
2165 unsigned int xid;
2167 xid = get_xid();
2168 /* this is probably better than directly calling
2169 partialpage_write since in this function the file handle is
2170 known which we might as well leverage */
2171 /* BB check if anything else missing out of ppw
2172 such as updating last write time */
2173 page_data = kmap(page);
2174 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2175 /* if (rc < 0) should we set writebehind rc? */
2176 kunmap(page);
2178 free_xid(xid);
2179 } else {
2180 rc = copied;
2181 pos += copied;
2182 set_page_dirty(page);
2185 if (rc > 0) {
2186 spin_lock(&inode->i_lock);
2187 if (pos > inode->i_size)
2188 i_size_write(inode, pos);
2189 spin_unlock(&inode->i_lock);
2192 unlock_page(page);
2193 page_cache_release(page);
2195 return rc;
2198 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2199 int datasync)
2201 unsigned int xid;
2202 int rc = 0;
2203 struct cifs_tcon *tcon;
2204 struct TCP_Server_Info *server;
2205 struct cifsFileInfo *smbfile = file->private_data;
2206 struct inode *inode = file_inode(file);
2207 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2209 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2210 if (rc)
2211 return rc;
2212 mutex_lock(&inode->i_mutex);
2214 xid = get_xid();
2216 cifs_dbg(FYI, "Sync file - name: %s datasync: 0x%x\n",
2217 file->f_path.dentry->d_name.name, datasync);
2219 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2220 rc = cifs_invalidate_mapping(inode);
2221 if (rc) {
2222 cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2223 rc = 0; /* don't care about it in fsync */
2227 tcon = tlink_tcon(smbfile->tlink);
2228 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2229 server = tcon->ses->server;
2230 if (server->ops->flush)
2231 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2232 else
2233 rc = -ENOSYS;
2236 free_xid(xid);
2237 mutex_unlock(&inode->i_mutex);
2238 return rc;
2241 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2243 unsigned int xid;
2244 int rc = 0;
2245 struct cifs_tcon *tcon;
2246 struct TCP_Server_Info *server;
2247 struct cifsFileInfo *smbfile = file->private_data;
2248 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2249 struct inode *inode = file->f_mapping->host;
2251 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2252 if (rc)
2253 return rc;
2254 mutex_lock(&inode->i_mutex);
2256 xid = get_xid();
2258 cifs_dbg(FYI, "Sync file - name: %s datasync: 0x%x\n",
2259 file->f_path.dentry->d_name.name, datasync);
2261 tcon = tlink_tcon(smbfile->tlink);
2262 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2263 server = tcon->ses->server;
2264 if (server->ops->flush)
2265 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2266 else
2267 rc = -ENOSYS;
2270 free_xid(xid);
2271 mutex_unlock(&inode->i_mutex);
2272 return rc;
2276 * As file closes, flush all cached write data for this inode checking
2277 * for write behind errors.
2279 int cifs_flush(struct file *file, fl_owner_t id)
2281 struct inode *inode = file_inode(file);
2282 int rc = 0;
2284 if (file->f_mode & FMODE_WRITE)
2285 rc = filemap_write_and_wait(inode->i_mapping);
2287 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2289 return rc;
2292 static int
2293 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2295 int rc = 0;
2296 unsigned long i;
2298 for (i = 0; i < num_pages; i++) {
2299 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2300 if (!pages[i]) {
2302 * save number of pages we have already allocated and
2303 * return with ENOMEM error
2305 num_pages = i;
2306 rc = -ENOMEM;
2307 break;
2311 if (rc) {
2312 for (i = 0; i < num_pages; i++)
2313 put_page(pages[i]);
2315 return rc;
2318 static inline
2319 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2321 size_t num_pages;
2322 size_t clen;
2324 clen = min_t(const size_t, len, wsize);
2325 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2327 if (cur_len)
2328 *cur_len = clen;
2330 return num_pages;
2333 static void
2334 cifs_uncached_writev_complete(struct work_struct *work)
2336 int i;
2337 struct cifs_writedata *wdata = container_of(work,
2338 struct cifs_writedata, work);
2339 struct inode *inode = wdata->cfile->dentry->d_inode;
2340 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2342 spin_lock(&inode->i_lock);
2343 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2344 if (cifsi->server_eof > inode->i_size)
2345 i_size_write(inode, cifsi->server_eof);
2346 spin_unlock(&inode->i_lock);
2348 complete(&wdata->done);
2350 if (wdata->result != -EAGAIN) {
2351 for (i = 0; i < wdata->nr_pages; i++)
2352 put_page(wdata->pages[i]);
2355 kref_put(&wdata->refcount, cifs_writedata_release);
2358 /* attempt to send write to server, retry on any -EAGAIN errors */
2359 static int
2360 cifs_uncached_retry_writev(struct cifs_writedata *wdata)
2362 int rc;
2363 struct TCP_Server_Info *server;
2365 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2367 do {
2368 if (wdata->cfile->invalidHandle) {
2369 rc = cifs_reopen_file(wdata->cfile, false);
2370 if (rc != 0)
2371 continue;
2373 rc = server->ops->async_writev(wdata);
2374 } while (rc == -EAGAIN);
2376 return rc;
2379 static ssize_t
2380 cifs_iovec_write(struct file *file, const struct iovec *iov,
2381 unsigned long nr_segs, loff_t *poffset)
2383 unsigned long nr_pages, i;
2384 size_t bytes, copied, len, cur_len;
2385 ssize_t total_written = 0;
2386 loff_t offset;
2387 struct iov_iter it;
2388 struct cifsFileInfo *open_file;
2389 struct cifs_tcon *tcon;
2390 struct cifs_sb_info *cifs_sb;
2391 struct cifs_writedata *wdata, *tmp;
2392 struct list_head wdata_list;
2393 int rc;
2394 pid_t pid;
2396 len = iov_length(iov, nr_segs);
2397 if (!len)
2398 return 0;
2400 rc = generic_write_checks(file, poffset, &len, 0);
2401 if (rc)
2402 return rc;
2404 INIT_LIST_HEAD(&wdata_list);
2405 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2406 open_file = file->private_data;
2407 tcon = tlink_tcon(open_file->tlink);
2409 if (!tcon->ses->server->ops->async_writev)
2410 return -ENOSYS;
2412 offset = *poffset;
2414 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2415 pid = open_file->pid;
2416 else
2417 pid = current->tgid;
2419 iov_iter_init(&it, iov, nr_segs, len, 0);
2420 do {
2421 size_t save_len;
2423 nr_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2424 wdata = cifs_writedata_alloc(nr_pages,
2425 cifs_uncached_writev_complete);
2426 if (!wdata) {
2427 rc = -ENOMEM;
2428 break;
2431 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2432 if (rc) {
2433 kfree(wdata);
2434 break;
2437 save_len = cur_len;
2438 for (i = 0; i < nr_pages; i++) {
2439 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2440 copied = iov_iter_copy_from_user(wdata->pages[i], &it,
2441 0, bytes);
2442 cur_len -= copied;
2443 iov_iter_advance(&it, copied);
2445 * If we didn't copy as much as we expected, then that
2446 * may mean we trod into an unmapped area. Stop copying
2447 * at that point. On the next pass through the big
2448 * loop, we'll likely end up getting a zero-length
2449 * write and bailing out of it.
2451 if (copied < bytes)
2452 break;
2454 cur_len = save_len - cur_len;
2457 * If we have no data to send, then that probably means that
2458 * the copy above failed altogether. That's most likely because
2459 * the address in the iovec was bogus. Set the rc to -EFAULT,
2460 * free anything we allocated and bail out.
2462 if (!cur_len) {
2463 for (i = 0; i < nr_pages; i++)
2464 put_page(wdata->pages[i]);
2465 kfree(wdata);
2466 rc = -EFAULT;
2467 break;
2471 * i + 1 now represents the number of pages we actually used in
2472 * the copy phase above. Bring nr_pages down to that, and free
2473 * any pages that we didn't use.
2475 for ( ; nr_pages > i + 1; nr_pages--)
2476 put_page(wdata->pages[nr_pages - 1]);
2478 wdata->sync_mode = WB_SYNC_ALL;
2479 wdata->nr_pages = nr_pages;
2480 wdata->offset = (__u64)offset;
2481 wdata->cfile = cifsFileInfo_get(open_file);
2482 wdata->pid = pid;
2483 wdata->bytes = cur_len;
2484 wdata->pagesz = PAGE_SIZE;
2485 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2486 rc = cifs_uncached_retry_writev(wdata);
2487 if (rc) {
2488 kref_put(&wdata->refcount, cifs_writedata_release);
2489 break;
2492 list_add_tail(&wdata->list, &wdata_list);
2493 offset += cur_len;
2494 len -= cur_len;
2495 } while (len > 0);
2498 * If at least one write was successfully sent, then discard any rc
2499 * value from the later writes. If the other write succeeds, then
2500 * we'll end up returning whatever was written. If it fails, then
2501 * we'll get a new rc value from that.
2503 if (!list_empty(&wdata_list))
2504 rc = 0;
2507 * Wait for and collect replies for any successful sends in order of
2508 * increasing offset. Once an error is hit or we get a fatal signal
2509 * while waiting, then return without waiting for any more replies.
2511 restart_loop:
2512 list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2513 if (!rc) {
2514 /* FIXME: freezable too? */
2515 rc = wait_for_completion_killable(&wdata->done);
2516 if (rc)
2517 rc = -EINTR;
2518 else if (wdata->result)
2519 rc = wdata->result;
2520 else
2521 total_written += wdata->bytes;
2523 /* resend call if it's a retryable error */
2524 if (rc == -EAGAIN) {
2525 rc = cifs_uncached_retry_writev(wdata);
2526 goto restart_loop;
2529 list_del_init(&wdata->list);
2530 kref_put(&wdata->refcount, cifs_writedata_release);
2533 if (total_written > 0)
2534 *poffset += total_written;
2536 cifs_stats_bytes_written(tcon, total_written);
2537 return total_written ? total_written : (ssize_t)rc;
2540 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2541 unsigned long nr_segs, loff_t pos)
2543 ssize_t written;
2544 struct inode *inode;
2546 inode = file_inode(iocb->ki_filp);
2549 * BB - optimize the way when signing is disabled. We can drop this
2550 * extra memory-to-memory copying and use iovec buffers for constructing
2551 * write request.
2554 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2555 if (written > 0) {
2556 CIFS_I(inode)->invalid_mapping = true;
2557 iocb->ki_pos = pos;
2560 return written;
2563 static ssize_t
2564 cifs_writev(struct kiocb *iocb, const struct iovec *iov,
2565 unsigned long nr_segs, loff_t pos)
2567 struct file *file = iocb->ki_filp;
2568 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2569 struct inode *inode = file->f_mapping->host;
2570 struct cifsInodeInfo *cinode = CIFS_I(inode);
2571 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2572 ssize_t rc = -EACCES;
2574 BUG_ON(iocb->ki_pos != pos);
2577 * We need to hold the sem to be sure nobody modifies lock list
2578 * with a brlock that prevents writing.
2580 down_read(&cinode->lock_sem);
2581 if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
2582 server->vals->exclusive_lock_type, NULL,
2583 CIFS_WRITE_OP)) {
2584 mutex_lock(&inode->i_mutex);
2585 rc = __generic_file_aio_write(iocb, iov, nr_segs,
2586 &iocb->ki_pos);
2587 mutex_unlock(&inode->i_mutex);
2590 if (rc > 0) {
2591 ssize_t err;
2593 err = generic_write_sync(file, pos, rc);
2594 if (err < 0 && rc > 0)
2595 rc = err;
2598 up_read(&cinode->lock_sem);
2599 return rc;
2602 ssize_t
2603 cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2604 unsigned long nr_segs, loff_t pos)
2606 struct inode *inode = file_inode(iocb->ki_filp);
2607 struct cifsInodeInfo *cinode = CIFS_I(inode);
2608 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2609 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2610 iocb->ki_filp->private_data;
2611 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2612 ssize_t written;
2614 written = cifs_get_writer(cinode);
2615 if (written)
2616 return written;
2618 if (CIFS_CACHE_WRITE(cinode)) {
2619 if (cap_unix(tcon->ses) &&
2620 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2621 && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
2622 written = generic_file_aio_write(
2623 iocb, iov, nr_segs, pos);
2624 goto out;
2626 written = cifs_writev(iocb, iov, nr_segs, pos);
2627 goto out;
2630 * For non-oplocked files in strict cache mode we need to write the data
2631 * to the server exactly from the pos to pos+len-1 rather than flush all
2632 * affected pages because it may cause a error with mandatory locks on
2633 * these pages but not on the region from pos to ppos+len-1.
2635 written = cifs_user_writev(iocb, iov, nr_segs, pos);
2636 if (written > 0 && CIFS_CACHE_READ(cinode)) {
2638 * Windows 7 server can delay breaking level2 oplock if a write
2639 * request comes - break it on the client to prevent reading
2640 * an old data.
2642 cifs_invalidate_mapping(inode);
2643 cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
2644 inode);
2645 cinode->oplock = 0;
2647 out:
2648 cifs_put_writer(cinode);
2649 return written;
2652 static struct cifs_readdata *
2653 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
2655 struct cifs_readdata *rdata;
2657 rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2658 GFP_KERNEL);
2659 if (rdata != NULL) {
2660 kref_init(&rdata->refcount);
2661 INIT_LIST_HEAD(&rdata->list);
2662 init_completion(&rdata->done);
2663 INIT_WORK(&rdata->work, complete);
2666 return rdata;
2669 void
2670 cifs_readdata_release(struct kref *refcount)
2672 struct cifs_readdata *rdata = container_of(refcount,
2673 struct cifs_readdata, refcount);
2675 if (rdata->cfile)
2676 cifsFileInfo_put(rdata->cfile);
2678 kfree(rdata);
2681 static int
2682 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2684 int rc = 0;
2685 struct page *page;
2686 unsigned int i;
2688 for (i = 0; i < nr_pages; i++) {
2689 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2690 if (!page) {
2691 rc = -ENOMEM;
2692 break;
2694 rdata->pages[i] = page;
2697 if (rc) {
2698 for (i = 0; i < nr_pages; i++) {
2699 put_page(rdata->pages[i]);
2700 rdata->pages[i] = NULL;
2703 return rc;
2706 static void
2707 cifs_uncached_readdata_release(struct kref *refcount)
2709 struct cifs_readdata *rdata = container_of(refcount,
2710 struct cifs_readdata, refcount);
2711 unsigned int i;
2713 for (i = 0; i < rdata->nr_pages; i++) {
2714 put_page(rdata->pages[i]);
2715 rdata->pages[i] = NULL;
2717 cifs_readdata_release(refcount);
2720 static int
2721 cifs_retry_async_readv(struct cifs_readdata *rdata)
2723 int rc;
2724 struct TCP_Server_Info *server;
2726 server = tlink_tcon(rdata->cfile->tlink)->ses->server;
2728 do {
2729 if (rdata->cfile->invalidHandle) {
2730 rc = cifs_reopen_file(rdata->cfile, true);
2731 if (rc != 0)
2732 continue;
2734 rc = server->ops->async_readv(rdata);
2735 } while (rc == -EAGAIN);
2737 return rc;
2741 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2742 * @rdata: the readdata response with list of pages holding data
2743 * @iov: vector in which we should copy the data
2744 * @nr_segs: number of segments in vector
2745 * @offset: offset into file of the first iovec
2746 * @copied: used to return the amount of data copied to the iov
2748 * This function copies data from a list of pages in a readdata response into
2749 * an array of iovecs. It will first calculate where the data should go
2750 * based on the info in the readdata and then copy the data into that spot.
2752 static ssize_t
2753 cifs_readdata_to_iov(struct cifs_readdata *rdata, const struct iovec *iov,
2754 unsigned long nr_segs, loff_t offset, ssize_t *copied)
2756 int rc = 0;
2757 struct iov_iter ii;
2758 size_t pos = rdata->offset - offset;
2759 ssize_t remaining = rdata->bytes;
2760 unsigned char *pdata;
2761 unsigned int i;
2763 /* set up iov_iter and advance to the correct offset */
2764 iov_iter_init(&ii, iov, nr_segs, iov_length(iov, nr_segs), 0);
2765 iov_iter_advance(&ii, pos);
2767 *copied = 0;
2768 for (i = 0; i < rdata->nr_pages; i++) {
2769 ssize_t copy;
2770 struct page *page = rdata->pages[i];
2772 /* copy a whole page or whatever's left */
2773 copy = min_t(ssize_t, remaining, PAGE_SIZE);
2775 /* ...but limit it to whatever space is left in the iov */
2776 copy = min_t(ssize_t, copy, iov_iter_count(&ii));
2778 /* go while there's data to be copied and no errors */
2779 if (copy && !rc) {
2780 pdata = kmap(page);
2781 rc = memcpy_toiovecend(ii.iov, pdata, ii.iov_offset,
2782 (int)copy);
2783 kunmap(page);
2784 if (!rc) {
2785 *copied += copy;
2786 remaining -= copy;
2787 iov_iter_advance(&ii, copy);
2792 return rc;
2795 static void
2796 cifs_uncached_readv_complete(struct work_struct *work)
2798 struct cifs_readdata *rdata = container_of(work,
2799 struct cifs_readdata, work);
2801 complete(&rdata->done);
2802 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2805 static int
2806 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2807 struct cifs_readdata *rdata, unsigned int len)
2809 int total_read = 0, result = 0;
2810 unsigned int i;
2811 unsigned int nr_pages = rdata->nr_pages;
2812 struct kvec iov;
2814 rdata->tailsz = PAGE_SIZE;
2815 for (i = 0; i < nr_pages; i++) {
2816 struct page *page = rdata->pages[i];
2818 if (len >= PAGE_SIZE) {
2819 /* enough data to fill the page */
2820 iov.iov_base = kmap(page);
2821 iov.iov_len = PAGE_SIZE;
2822 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2823 i, iov.iov_base, iov.iov_len);
2824 len -= PAGE_SIZE;
2825 } else if (len > 0) {
2826 /* enough for partial page, fill and zero the rest */
2827 iov.iov_base = kmap(page);
2828 iov.iov_len = len;
2829 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2830 i, iov.iov_base, iov.iov_len);
2831 memset(iov.iov_base + len, '\0', PAGE_SIZE - len);
2832 rdata->tailsz = len;
2833 len = 0;
2834 } else {
2835 /* no need to hold page hostage */
2836 rdata->pages[i] = NULL;
2837 rdata->nr_pages--;
2838 put_page(page);
2839 continue;
2842 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
2843 kunmap(page);
2844 if (result < 0)
2845 break;
2847 total_read += result;
2850 return total_read > 0 ? total_read : result;
2853 static ssize_t
2854 cifs_iovec_read(struct file *file, const struct iovec *iov,
2855 unsigned long nr_segs, loff_t *poffset)
2857 ssize_t rc;
2858 size_t len, cur_len;
2859 ssize_t total_read = 0;
2860 loff_t offset = *poffset;
2861 unsigned int npages;
2862 struct cifs_sb_info *cifs_sb;
2863 struct cifs_tcon *tcon;
2864 struct cifsFileInfo *open_file;
2865 struct cifs_readdata *rdata, *tmp;
2866 struct list_head rdata_list;
2867 pid_t pid;
2869 if (!nr_segs)
2870 return 0;
2872 len = iov_length(iov, nr_segs);
2873 if (!len)
2874 return 0;
2876 INIT_LIST_HEAD(&rdata_list);
2877 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2878 open_file = file->private_data;
2879 tcon = tlink_tcon(open_file->tlink);
2881 if (!tcon->ses->server->ops->async_readv)
2882 return -ENOSYS;
2884 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2885 pid = open_file->pid;
2886 else
2887 pid = current->tgid;
2889 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2890 cifs_dbg(FYI, "attempting read on write only file instance\n");
2892 do {
2893 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
2894 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
2896 /* allocate a readdata struct */
2897 rdata = cifs_readdata_alloc(npages,
2898 cifs_uncached_readv_complete);
2899 if (!rdata) {
2900 rc = -ENOMEM;
2901 goto error;
2904 rc = cifs_read_allocate_pages(rdata, npages);
2905 if (rc)
2906 goto error;
2908 rdata->cfile = cifsFileInfo_get(open_file);
2909 rdata->nr_pages = npages;
2910 rdata->offset = offset;
2911 rdata->bytes = cur_len;
2912 rdata->pid = pid;
2913 rdata->pagesz = PAGE_SIZE;
2914 rdata->read_into_pages = cifs_uncached_read_into_pages;
2916 rc = cifs_retry_async_readv(rdata);
2917 error:
2918 if (rc) {
2919 kref_put(&rdata->refcount,
2920 cifs_uncached_readdata_release);
2921 break;
2924 list_add_tail(&rdata->list, &rdata_list);
2925 offset += cur_len;
2926 len -= cur_len;
2927 } while (len > 0);
2929 /* if at least one read request send succeeded, then reset rc */
2930 if (!list_empty(&rdata_list))
2931 rc = 0;
2933 /* the loop below should proceed in the order of increasing offsets */
2934 restart_loop:
2935 list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
2936 if (!rc) {
2937 ssize_t copied;
2939 /* FIXME: freezable sleep too? */
2940 rc = wait_for_completion_killable(&rdata->done);
2941 if (rc)
2942 rc = -EINTR;
2943 else if (rdata->result)
2944 rc = rdata->result;
2945 else {
2946 rc = cifs_readdata_to_iov(rdata, iov,
2947 nr_segs, *poffset,
2948 &copied);
2949 total_read += copied;
2952 /* resend call if it's a retryable error */
2953 if (rc == -EAGAIN) {
2954 rc = cifs_retry_async_readv(rdata);
2955 goto restart_loop;
2958 list_del_init(&rdata->list);
2959 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2962 cifs_stats_bytes_read(tcon, total_read);
2963 *poffset += total_read;
2965 /* mask nodata case */
2966 if (rc == -ENODATA)
2967 rc = 0;
2969 return total_read ? total_read : rc;
2972 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2973 unsigned long nr_segs, loff_t pos)
2975 ssize_t read;
2977 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2978 if (read > 0)
2979 iocb->ki_pos = pos;
2981 return read;
2984 ssize_t
2985 cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2986 unsigned long nr_segs, loff_t pos)
2988 struct inode *inode = file_inode(iocb->ki_filp);
2989 struct cifsInodeInfo *cinode = CIFS_I(inode);
2990 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2991 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2992 iocb->ki_filp->private_data;
2993 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2994 int rc = -EACCES;
2997 * In strict cache mode we need to read from the server all the time
2998 * if we don't have level II oplock because the server can delay mtime
2999 * change - so we can't make a decision about inode invalidating.
3000 * And we can also fail with pagereading if there are mandatory locks
3001 * on pages affected by this read but not on the region from pos to
3002 * pos+len-1.
3004 if (!CIFS_CACHE_READ(cinode))
3005 return cifs_user_readv(iocb, iov, nr_segs, pos);
3007 if (cap_unix(tcon->ses) &&
3008 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3009 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
3010 return generic_file_aio_read(iocb, iov, nr_segs, pos);
3013 * We need to hold the sem to be sure nobody modifies lock list
3014 * with a brlock that prevents reading.
3016 down_read(&cinode->lock_sem);
3017 if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
3018 tcon->ses->server->vals->shared_lock_type,
3019 NULL, CIFS_READ_OP))
3020 rc = generic_file_aio_read(iocb, iov, nr_segs, pos);
3021 up_read(&cinode->lock_sem);
3022 return rc;
3025 static ssize_t
3026 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
3028 int rc = -EACCES;
3029 unsigned int bytes_read = 0;
3030 unsigned int total_read;
3031 unsigned int current_read_size;
3032 unsigned int rsize;
3033 struct cifs_sb_info *cifs_sb;
3034 struct cifs_tcon *tcon;
3035 struct TCP_Server_Info *server;
3036 unsigned int xid;
3037 char *cur_offset;
3038 struct cifsFileInfo *open_file;
3039 struct cifs_io_parms io_parms;
3040 int buf_type = CIFS_NO_BUFFER;
3041 __u32 pid;
3043 xid = get_xid();
3044 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
3046 /* FIXME: set up handlers for larger reads and/or convert to async */
3047 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3049 if (file->private_data == NULL) {
3050 rc = -EBADF;
3051 free_xid(xid);
3052 return rc;
3054 open_file = file->private_data;
3055 tcon = tlink_tcon(open_file->tlink);
3056 server = tcon->ses->server;
3058 if (!server->ops->sync_read) {
3059 free_xid(xid);
3060 return -ENOSYS;
3063 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3064 pid = open_file->pid;
3065 else
3066 pid = current->tgid;
3068 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3069 cifs_dbg(FYI, "attempting read on write only file instance\n");
3071 for (total_read = 0, cur_offset = read_data; read_size > total_read;
3072 total_read += bytes_read, cur_offset += bytes_read) {
3073 current_read_size = min_t(uint, read_size - total_read, rsize);
3075 * For windows me and 9x we do not want to request more than it
3076 * negotiated since it will refuse the read then.
3078 if ((tcon->ses) && !(tcon->ses->capabilities &
3079 tcon->ses->server->vals->cap_large_files)) {
3080 current_read_size = min_t(uint, current_read_size,
3081 CIFSMaxBufSize);
3083 rc = -EAGAIN;
3084 while (rc == -EAGAIN) {
3085 if (open_file->invalidHandle) {
3086 rc = cifs_reopen_file(open_file, true);
3087 if (rc != 0)
3088 break;
3090 io_parms.pid = pid;
3091 io_parms.tcon = tcon;
3092 io_parms.offset = *offset;
3093 io_parms.length = current_read_size;
3094 rc = server->ops->sync_read(xid, open_file, &io_parms,
3095 &bytes_read, &cur_offset,
3096 &buf_type);
3098 if (rc || (bytes_read == 0)) {
3099 if (total_read) {
3100 break;
3101 } else {
3102 free_xid(xid);
3103 return rc;
3105 } else {
3106 cifs_stats_bytes_read(tcon, total_read);
3107 *offset += bytes_read;
3110 free_xid(xid);
3111 return total_read;
3115 * If the page is mmap'ed into a process' page tables, then we need to make
3116 * sure that it doesn't change while being written back.
3118 static int
3119 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
3121 struct page *page = vmf->page;
3123 lock_page(page);
3124 return VM_FAULT_LOCKED;
3127 static struct vm_operations_struct cifs_file_vm_ops = {
3128 .fault = filemap_fault,
3129 .page_mkwrite = cifs_page_mkwrite,
3130 .remap_pages = generic_file_remap_pages,
3133 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3135 int rc, xid;
3136 struct inode *inode = file_inode(file);
3138 xid = get_xid();
3140 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
3141 rc = cifs_invalidate_mapping(inode);
3142 if (rc)
3143 return rc;
3146 rc = generic_file_mmap(file, vma);
3147 if (rc == 0)
3148 vma->vm_ops = &cifs_file_vm_ops;
3149 free_xid(xid);
3150 return rc;
3153 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3155 int rc, xid;
3157 xid = get_xid();
3158 rc = cifs_revalidate_file(file);
3159 if (rc) {
3160 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3161 rc);
3162 free_xid(xid);
3163 return rc;
3165 rc = generic_file_mmap(file, vma);
3166 if (rc == 0)
3167 vma->vm_ops = &cifs_file_vm_ops;
3168 free_xid(xid);
3169 return rc;
3172 static void
3173 cifs_readv_complete(struct work_struct *work)
3175 unsigned int i;
3176 struct cifs_readdata *rdata = container_of(work,
3177 struct cifs_readdata, work);
3179 for (i = 0; i < rdata->nr_pages; i++) {
3180 struct page *page = rdata->pages[i];
3182 lru_cache_add_file(page);
3184 if (rdata->result == 0) {
3185 flush_dcache_page(page);
3186 SetPageUptodate(page);
3189 unlock_page(page);
3191 if (rdata->result == 0)
3192 cifs_readpage_to_fscache(rdata->mapping->host, page);
3194 page_cache_release(page);
3195 rdata->pages[i] = NULL;
3197 kref_put(&rdata->refcount, cifs_readdata_release);
3200 static int
3201 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3202 struct cifs_readdata *rdata, unsigned int len)
3204 int total_read = 0, result = 0;
3205 unsigned int i;
3206 u64 eof;
3207 pgoff_t eof_index;
3208 unsigned int nr_pages = rdata->nr_pages;
3209 struct kvec iov;
3211 /* determine the eof that the server (probably) has */
3212 eof = CIFS_I(rdata->mapping->host)->server_eof;
3213 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
3214 cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
3216 rdata->tailsz = PAGE_CACHE_SIZE;
3217 for (i = 0; i < nr_pages; i++) {
3218 struct page *page = rdata->pages[i];
3220 if (len >= PAGE_CACHE_SIZE) {
3221 /* enough data to fill the page */
3222 iov.iov_base = kmap(page);
3223 iov.iov_len = PAGE_CACHE_SIZE;
3224 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3225 i, page->index, iov.iov_base, iov.iov_len);
3226 len -= PAGE_CACHE_SIZE;
3227 } else if (len > 0) {
3228 /* enough for partial page, fill and zero the rest */
3229 iov.iov_base = kmap(page);
3230 iov.iov_len = len;
3231 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3232 i, page->index, iov.iov_base, iov.iov_len);
3233 memset(iov.iov_base + len,
3234 '\0', PAGE_CACHE_SIZE - len);
3235 rdata->tailsz = len;
3236 len = 0;
3237 } else if (page->index > eof_index) {
3239 * The VFS will not try to do readahead past the
3240 * i_size, but it's possible that we have outstanding
3241 * writes with gaps in the middle and the i_size hasn't
3242 * caught up yet. Populate those with zeroed out pages
3243 * to prevent the VFS from repeatedly attempting to
3244 * fill them until the writes are flushed.
3246 zero_user(page, 0, PAGE_CACHE_SIZE);
3247 lru_cache_add_file(page);
3248 flush_dcache_page(page);
3249 SetPageUptodate(page);
3250 unlock_page(page);
3251 page_cache_release(page);
3252 rdata->pages[i] = NULL;
3253 rdata->nr_pages--;
3254 continue;
3255 } else {
3256 /* no need to hold page hostage */
3257 lru_cache_add_file(page);
3258 unlock_page(page);
3259 page_cache_release(page);
3260 rdata->pages[i] = NULL;
3261 rdata->nr_pages--;
3262 continue;
3265 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
3266 kunmap(page);
3267 if (result < 0)
3268 break;
3270 total_read += result;
3273 return total_read > 0 ? total_read : result;
3276 static int cifs_readpages(struct file *file, struct address_space *mapping,
3277 struct list_head *page_list, unsigned num_pages)
3279 int rc;
3280 struct list_head tmplist;
3281 struct cifsFileInfo *open_file = file->private_data;
3282 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
3283 unsigned int rsize = cifs_sb->rsize;
3284 pid_t pid;
3287 * Give up immediately if rsize is too small to read an entire page.
3288 * The VFS will fall back to readpage. We should never reach this
3289 * point however since we set ra_pages to 0 when the rsize is smaller
3290 * than a cache page.
3292 if (unlikely(rsize < PAGE_CACHE_SIZE))
3293 return 0;
3296 * Reads as many pages as possible from fscache. Returns -ENOBUFS
3297 * immediately if the cookie is negative
3299 * After this point, every page in the list might have PG_fscache set,
3300 * so we will need to clean that up off of every page we don't use.
3302 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3303 &num_pages);
3304 if (rc == 0)
3305 return rc;
3307 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3308 pid = open_file->pid;
3309 else
3310 pid = current->tgid;
3312 rc = 0;
3313 INIT_LIST_HEAD(&tmplist);
3315 cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
3316 __func__, file, mapping, num_pages);
3319 * Start with the page at end of list and move it to private
3320 * list. Do the same with any following pages until we hit
3321 * the rsize limit, hit an index discontinuity, or run out of
3322 * pages. Issue the async read and then start the loop again
3323 * until the list is empty.
3325 * Note that list order is important. The page_list is in
3326 * the order of declining indexes. When we put the pages in
3327 * the rdata->pages, then we want them in increasing order.
3329 while (!list_empty(page_list)) {
3330 unsigned int i;
3331 unsigned int bytes = PAGE_CACHE_SIZE;
3332 unsigned int expected_index;
3333 unsigned int nr_pages = 1;
3334 loff_t offset;
3335 struct page *page, *tpage;
3336 struct cifs_readdata *rdata;
3338 page = list_entry(page_list->prev, struct page, lru);
3341 * Lock the page and put it in the cache. Since no one else
3342 * should have access to this page, we're safe to simply set
3343 * PG_locked without checking it first.
3345 __set_page_locked(page);
3346 rc = add_to_page_cache_locked(page, mapping,
3347 page->index, GFP_KERNEL);
3349 /* give up if we can't stick it in the cache */
3350 if (rc) {
3351 __clear_page_locked(page);
3352 break;
3355 /* move first page to the tmplist */
3356 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3357 list_move_tail(&page->lru, &tmplist);
3359 /* now try and add more pages onto the request */
3360 expected_index = page->index + 1;
3361 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3362 /* discontinuity ? */
3363 if (page->index != expected_index)
3364 break;
3366 /* would this page push the read over the rsize? */
3367 if (bytes + PAGE_CACHE_SIZE > rsize)
3368 break;
3370 __set_page_locked(page);
3371 if (add_to_page_cache_locked(page, mapping,
3372 page->index, GFP_KERNEL)) {
3373 __clear_page_locked(page);
3374 break;
3376 list_move_tail(&page->lru, &tmplist);
3377 bytes += PAGE_CACHE_SIZE;
3378 expected_index++;
3379 nr_pages++;
3382 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3383 if (!rdata) {
3384 /* best to give up if we're out of mem */
3385 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3386 list_del(&page->lru);
3387 lru_cache_add_file(page);
3388 unlock_page(page);
3389 page_cache_release(page);
3391 rc = -ENOMEM;
3392 break;
3395 rdata->cfile = cifsFileInfo_get(open_file);
3396 rdata->mapping = mapping;
3397 rdata->offset = offset;
3398 rdata->bytes = bytes;
3399 rdata->pid = pid;
3400 rdata->pagesz = PAGE_CACHE_SIZE;
3401 rdata->read_into_pages = cifs_readpages_read_into_pages;
3403 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3404 list_del(&page->lru);
3405 rdata->pages[rdata->nr_pages++] = page;
3408 rc = cifs_retry_async_readv(rdata);
3409 if (rc != 0) {
3410 for (i = 0; i < rdata->nr_pages; i++) {
3411 page = rdata->pages[i];
3412 lru_cache_add_file(page);
3413 unlock_page(page);
3414 page_cache_release(page);
3416 kref_put(&rdata->refcount, cifs_readdata_release);
3417 break;
3420 kref_put(&rdata->refcount, cifs_readdata_release);
3423 /* Any pages that have been shown to fscache but didn't get added to
3424 * the pagecache must be uncached before they get returned to the
3425 * allocator.
3427 cifs_fscache_readpages_cancel(mapping->host, page_list);
3428 return rc;
3432 * cifs_readpage_worker must be called with the page pinned
3434 static int cifs_readpage_worker(struct file *file, struct page *page,
3435 loff_t *poffset)
3437 char *read_data;
3438 int rc;
3440 /* Is the page cached? */
3441 rc = cifs_readpage_from_fscache(file_inode(file), page);
3442 if (rc == 0)
3443 goto read_complete;
3445 read_data = kmap(page);
3446 /* for reads over a certain size could initiate async read ahead */
3448 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
3450 if (rc < 0)
3451 goto io_error;
3452 else
3453 cifs_dbg(FYI, "Bytes read %d\n", rc);
3455 file_inode(file)->i_atime =
3456 current_fs_time(file_inode(file)->i_sb);
3458 if (PAGE_CACHE_SIZE > rc)
3459 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
3461 flush_dcache_page(page);
3462 SetPageUptodate(page);
3464 /* send this page to the cache */
3465 cifs_readpage_to_fscache(file_inode(file), page);
3467 rc = 0;
3469 io_error:
3470 kunmap(page);
3471 unlock_page(page);
3473 read_complete:
3474 return rc;
3477 static int cifs_readpage(struct file *file, struct page *page)
3479 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3480 int rc = -EACCES;
3481 unsigned int xid;
3483 xid = get_xid();
3485 if (file->private_data == NULL) {
3486 rc = -EBADF;
3487 free_xid(xid);
3488 return rc;
3491 cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
3492 page, (int)offset, (int)offset);
3494 rc = cifs_readpage_worker(file, page, &offset);
3496 free_xid(xid);
3497 return rc;
3500 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3502 struct cifsFileInfo *open_file;
3504 spin_lock(&cifs_file_list_lock);
3505 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3506 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3507 spin_unlock(&cifs_file_list_lock);
3508 return 1;
3511 spin_unlock(&cifs_file_list_lock);
3512 return 0;
3515 /* We do not want to update the file size from server for inodes
3516 open for write - to avoid races with writepage extending
3517 the file - in the future we could consider allowing
3518 refreshing the inode only on increases in the file size
3519 but this is tricky to do without racing with writebehind
3520 page caching in the current Linux kernel design */
3521 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
3523 if (!cifsInode)
3524 return true;
3526 if (is_inode_writable(cifsInode)) {
3527 /* This inode is open for write at least once */
3528 struct cifs_sb_info *cifs_sb;
3530 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
3531 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
3532 /* since no page cache to corrupt on directio
3533 we can change size safely */
3534 return true;
3537 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3538 return true;
3540 return false;
3541 } else
3542 return true;
3545 static int cifs_write_begin(struct file *file, struct address_space *mapping,
3546 loff_t pos, unsigned len, unsigned flags,
3547 struct page **pagep, void **fsdata)
3549 int oncethru = 0;
3550 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3551 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
3552 loff_t page_start = pos & PAGE_MASK;
3553 loff_t i_size;
3554 struct page *page;
3555 int rc = 0;
3557 cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
3559 start:
3560 page = grab_cache_page_write_begin(mapping, index, flags);
3561 if (!page) {
3562 rc = -ENOMEM;
3563 goto out;
3566 if (PageUptodate(page))
3567 goto out;
3570 * If we write a full page it will be up to date, no need to read from
3571 * the server. If the write is short, we'll end up doing a sync write
3572 * instead.
3574 if (len == PAGE_CACHE_SIZE)
3575 goto out;
3578 * optimize away the read when we have an oplock, and we're not
3579 * expecting to use any of the data we'd be reading in. That
3580 * is, when the page lies beyond the EOF, or straddles the EOF
3581 * and the write will cover all of the existing data.
3583 if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
3584 i_size = i_size_read(mapping->host);
3585 if (page_start >= i_size ||
3586 (offset == 0 && (pos + len) >= i_size)) {
3587 zero_user_segments(page, 0, offset,
3588 offset + len,
3589 PAGE_CACHE_SIZE);
3591 * PageChecked means that the parts of the page
3592 * to which we're not writing are considered up
3593 * to date. Once the data is copied to the
3594 * page, it can be set uptodate.
3596 SetPageChecked(page);
3597 goto out;
3601 if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
3603 * might as well read a page, it is fast enough. If we get
3604 * an error, we don't need to return it. cifs_write_end will
3605 * do a sync write instead since PG_uptodate isn't set.
3607 cifs_readpage_worker(file, page, &page_start);
3608 page_cache_release(page);
3609 oncethru = 1;
3610 goto start;
3611 } else {
3612 /* we could try using another file handle if there is one -
3613 but how would we lock it to prevent close of that handle
3614 racing with this read? In any case
3615 this will be written out by write_end so is fine */
3617 out:
3618 *pagep = page;
3619 return rc;
3622 static int cifs_release_page(struct page *page, gfp_t gfp)
3624 if (PagePrivate(page))
3625 return 0;
3627 return cifs_fscache_release_page(page, gfp);
3630 static void cifs_invalidate_page(struct page *page, unsigned int offset,
3631 unsigned int length)
3633 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3635 if (offset == 0 && length == PAGE_CACHE_SIZE)
3636 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3639 static int cifs_launder_page(struct page *page)
3641 int rc = 0;
3642 loff_t range_start = page_offset(page);
3643 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3644 struct writeback_control wbc = {
3645 .sync_mode = WB_SYNC_ALL,
3646 .nr_to_write = 0,
3647 .range_start = range_start,
3648 .range_end = range_end,
3651 cifs_dbg(FYI, "Launder page: %p\n", page);
3653 if (clear_page_dirty_for_io(page))
3654 rc = cifs_writepage_locked(page, &wbc);
3656 cifs_fscache_invalidate_page(page, page->mapping->host);
3657 return rc;
3660 static int
3661 cifs_pending_writers_wait(void *unused)
3663 schedule();
3664 return 0;
3667 void cifs_oplock_break(struct work_struct *work)
3669 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3670 oplock_break);
3671 struct inode *inode = cfile->dentry->d_inode;
3672 struct cifsInodeInfo *cinode = CIFS_I(inode);
3673 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3674 struct TCP_Server_Info *server = tcon->ses->server;
3675 int rc = 0;
3677 wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
3678 cifs_pending_writers_wait, TASK_UNINTERRUPTIBLE);
3680 server->ops->downgrade_oplock(server, cinode,
3681 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, &cinode->flags));
3683 if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
3684 cifs_has_mand_locks(cinode)) {
3685 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
3686 inode);
3687 cinode->oplock = 0;
3690 if (inode && S_ISREG(inode->i_mode)) {
3691 if (CIFS_CACHE_READ(cinode))
3692 break_lease(inode, O_RDONLY);
3693 else
3694 break_lease(inode, O_WRONLY);
3695 rc = filemap_fdatawrite(inode->i_mapping);
3696 if (!CIFS_CACHE_READ(cinode)) {
3697 rc = filemap_fdatawait(inode->i_mapping);
3698 mapping_set_error(inode->i_mapping, rc);
3699 cifs_invalidate_mapping(inode);
3701 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
3704 rc = cifs_push_locks(cfile);
3705 if (rc)
3706 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
3709 * releasing stale oplock after recent reconnect of smb session using
3710 * a now incorrect file handle is not a data integrity issue but do
3711 * not bother sending an oplock release if session to server still is
3712 * disconnected since oplock already released by the server
3714 if (!cfile->oplock_break_cancelled) {
3715 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
3716 cinode);
3717 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
3719 cifs_done_oplock_break(cinode);
3722 const struct address_space_operations cifs_addr_ops = {
3723 .readpage = cifs_readpage,
3724 .readpages = cifs_readpages,
3725 .writepage = cifs_writepage,
3726 .writepages = cifs_writepages,
3727 .write_begin = cifs_write_begin,
3728 .write_end = cifs_write_end,
3729 .set_page_dirty = __set_page_dirty_nobuffers,
3730 .releasepage = cifs_release_page,
3731 .invalidatepage = cifs_invalidate_page,
3732 .launder_page = cifs_launder_page,
3736 * cifs_readpages requires the server to support a buffer large enough to
3737 * contain the header plus one complete page of data. Otherwise, we need
3738 * to leave cifs_readpages out of the address space operations.
3740 const struct address_space_operations cifs_addr_ops_smallbuf = {
3741 .readpage = cifs_readpage,
3742 .writepage = cifs_writepage,
3743 .writepages = cifs_writepages,
3744 .write_begin = cifs_write_begin,
3745 .write_end = cifs_write_end,
3746 .set_page_dirty = __set_page_dirty_nobuffers,
3747 .releasepage = cifs_release_page,
3748 .invalidatepage = cifs_invalidate_page,
3749 .launder_page = cifs_launder_page,