1 /*
2 * fs/cifs/file.c
3 *
4 * vfs operations that deal with files
5 *
6 * Copyright (C) International Business Machines Corp., 2002,2010
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 * Jeremy Allison (jra@samba.org)
9 *
10 * This library is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU Lesser General Public License as published
12 * by the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24 #include <linux/fs.h>
25 #include <linux/backing-dev.h>
26 #include <linux/stat.h>
27 #include <linux/fcntl.h>
28 #include <linux/pagemap.h>
29 #include <linux/pagevec.h>
30 #include <linux/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"
45
46
47 static inline int cifs_convert_flags(unsigned int flags)
48 {
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);
58 }
59
60 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
61 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
62 FILE_READ_DATA);
63 }
64
65 static u32 cifs_posix_convert_flags(unsigned int flags)
66 {
67 u32 posix_flags = 0;
68
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;
75
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);
83
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;
95
96 return posix_flags;
97 }
98
99 static inline int cifs_get_disposition(unsigned int flags)
100 {
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;
111 }
112
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)
116 {
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;
124
125 cifs_dbg(FYI, "posix open %s\n", full_path);
126
127 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
128 if (presp_data == NULL)
129 return -ENOMEM;
130
131 tlink = cifs_sb_tlink(cifs_sb);
132 if (IS_ERR(tlink)) {
133 rc = PTR_ERR(tlink);
134 goto posix_open_ret;
135 }
136
137 tcon = tlink_tcon(tlink);
138 mode &= ~current_umask();
139
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_remap(cifs_sb));
144 cifs_put_tlink(tlink);
145
146 if (rc)
147 goto posix_open_ret;
148
149 if (presp_data->Type == cpu_to_le32(-1))
150 goto posix_open_ret; /* open ok, caller does qpathinfo */
151
152 if (!pinode)
153 goto posix_open_ret; /* caller does not need info */
154
155 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
156
157 /* get new inode and set it up */
158 if (*pinode == NULL) {
159 cifs_fill_uniqueid(sb, &fattr);
160 *pinode = cifs_iget(sb, &fattr);
161 if (!*pinode) {
162 rc = -ENOMEM;
163 goto posix_open_ret;
164 }
165 } else {
166 cifs_fattr_to_inode(*pinode, &fattr);
167 }
168
169 posix_open_ret:
170 kfree(presp_data);
171 return rc;
172 }
173
174 static int
175 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
176 struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
177 struct cifs_fid *fid, unsigned int xid)
178 {
179 int rc;
180 int desired_access;
181 int disposition;
182 int create_options = CREATE_NOT_DIR;
183 FILE_ALL_INFO *buf;
184 struct TCP_Server_Info *server = tcon->ses->server;
185 struct cifs_open_parms oparms;
186
187 if (!server->ops->open)
188 return -ENOSYS;
189
190 desired_access = cifs_convert_flags(f_flags);
191
192 /*********************************************************************
193 * open flag mapping table:
194 *
195 * POSIX Flag CIFS Disposition
196 * ---------- ----------------
197 * O_CREAT FILE_OPEN_IF
198 * O_CREAT | O_EXCL FILE_CREATE
199 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
200 * O_TRUNC FILE_OVERWRITE
201 * none of the above FILE_OPEN
202 *
203 * Note that there is not a direct match between disposition
204 * FILE_SUPERSEDE (ie create whether or not file exists although
205 * O_CREAT | O_TRUNC is similar but truncates the existing
206 * file rather than creating a new file as FILE_SUPERSEDE does
207 * (which uses the attributes / metadata passed in on open call)
208 *?
209 *? O_SYNC is a reasonable match to CIFS writethrough flag
210 *? and the read write flags match reasonably. O_LARGEFILE
211 *? is irrelevant because largefile support is always used
212 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
213 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
214 *********************************************************************/
215
216 disposition = cifs_get_disposition(f_flags);
217
218 /* BB pass O_SYNC flag through on file attributes .. BB */
219
220 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
221 if (!buf)
222 return -ENOMEM;
223
224 if (backup_cred(cifs_sb))
225 create_options |= CREATE_OPEN_BACKUP_INTENT;
226
227 /* O_SYNC also has bit for O_DSYNC so following check picks up either */
228 if (f_flags & O_SYNC)
229 create_options |= CREATE_WRITE_THROUGH;
230
231 if (f_flags & O_DIRECT)
232 create_options |= CREATE_NO_BUFFER;
233
234 oparms.tcon = tcon;
235 oparms.cifs_sb = cifs_sb;
236 oparms.desired_access = desired_access;
237 oparms.create_options = create_options;
238 oparms.disposition = disposition;
239 oparms.path = full_path;
240 oparms.fid = fid;
241 oparms.reconnect = false;
242
243 rc = server->ops->open(xid, &oparms, oplock, buf);
244
245 if (rc)
246 goto out;
247
248 if (tcon->unix_ext)
249 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
250 xid);
251 else
252 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
253 xid, fid);
254
255 out:
256 kfree(buf);
257 return rc;
258 }
259
260 static bool
261 cifs_has_mand_locks(struct cifsInodeInfo *cinode)
262 {
263 struct cifs_fid_locks *cur;
264 bool has_locks = false;
265
266 down_read(&cinode->lock_sem);
267 list_for_each_entry(cur, &cinode->llist, llist) {
268 if (!list_empty(&cur->locks)) {
269 has_locks = true;
270 break;
271 }
272 }
273 up_read(&cinode->lock_sem);
274 return has_locks;
275 }
276
277 struct cifsFileInfo *
278 cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
279 struct tcon_link *tlink, __u32 oplock)
280 {
281 struct dentry *dentry = file_dentry(file);
282 struct inode *inode = d_inode(dentry);
283 struct cifsInodeInfo *cinode = CIFS_I(inode);
284 struct cifsFileInfo *cfile;
285 struct cifs_fid_locks *fdlocks;
286 struct cifs_tcon *tcon = tlink_tcon(tlink);
287 struct TCP_Server_Info *server = tcon->ses->server;
288
289 cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
290 if (cfile == NULL)
291 return cfile;
292
293 fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
294 if (!fdlocks) {
295 kfree(cfile);
296 return NULL;
297 }
298
299 INIT_LIST_HEAD(&fdlocks->locks);
300 fdlocks->cfile = cfile;
301 cfile->llist = fdlocks;
302 down_write(&cinode->lock_sem);
303 list_add(&fdlocks->llist, &cinode->llist);
304 up_write(&cinode->lock_sem);
305
306 cfile->count = 1;
307 cfile->pid = current->tgid;
308 cfile->uid = current_fsuid();
309 cfile->dentry = dget(dentry);
310 cfile->f_flags = file->f_flags;
311 cfile->invalidHandle = false;
312 cfile->tlink = cifs_get_tlink(tlink);
313 INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
314 mutex_init(&cfile->fh_mutex);
315 spin_lock_init(&cfile->file_info_lock);
316
317 cifs_sb_active(inode->i_sb);
318
319 /*
320 * If the server returned a read oplock and we have mandatory brlocks,
321 * set oplock level to None.
322 */
323 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
324 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
325 oplock = 0;
326 }
327
328 spin_lock(&tcon->open_file_lock);
329 if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
330 oplock = fid->pending_open->oplock;
331 list_del(&fid->pending_open->olist);
332
333 fid->purge_cache = false;
334 server->ops->set_fid(cfile, fid, oplock);
335
336 list_add(&cfile->tlist, &tcon->openFileList);
337
338 /* if readable file instance put first in list*/
339 if (file->f_mode & FMODE_READ)
340 list_add(&cfile->flist, &cinode->openFileList);
341 else
342 list_add_tail(&cfile->flist, &cinode->openFileList);
343 spin_unlock(&tcon->open_file_lock);
344
345 if (fid->purge_cache)
346 cifs_zap_mapping(inode);
347
348 file->private_data = cfile;
349 return cfile;
350 }
351
352 struct cifsFileInfo *
353 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
354 {
355 spin_lock(&cifs_file->file_info_lock);
356 cifsFileInfo_get_locked(cifs_file);
357 spin_unlock(&cifs_file->file_info_lock);
358 return cifs_file;
359 }
360
361 /*
362 * Release a reference on the file private data. This may involve closing
363 * the filehandle out on the server. Must be called without holding
364 * tcon->open_file_lock and cifs_file->file_info_lock.
365 */
366 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
367 {
368 struct inode *inode = d_inode(cifs_file->dentry);
369 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
370 struct TCP_Server_Info *server = tcon->ses->server;
371 struct cifsInodeInfo *cifsi = CIFS_I(inode);
372 struct super_block *sb = inode->i_sb;
373 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
374 struct cifsLockInfo *li, *tmp;
375 struct cifs_fid fid;
376 struct cifs_pending_open open;
377 bool oplock_break_cancelled;
378
379 spin_lock(&tcon->open_file_lock);
380
381 spin_lock(&cifs_file->file_info_lock);
382 if (--cifs_file->count > 0) {
383 spin_unlock(&cifs_file->file_info_lock);
384 spin_unlock(&tcon->open_file_lock);
385 return;
386 }
387 spin_unlock(&cifs_file->file_info_lock);
388
389 if (server->ops->get_lease_key)
390 server->ops->get_lease_key(inode, &fid);
391
392 /* store open in pending opens to make sure we don't miss lease break */
393 cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
394
395 /* remove it from the lists */
396 list_del(&cifs_file->flist);
397 list_del(&cifs_file->tlist);
398
399 if (list_empty(&cifsi->openFileList)) {
400 cifs_dbg(FYI, "closing last open instance for inode %p\n",
401 d_inode(cifs_file->dentry));
402 /*
403 * In strict cache mode we need invalidate mapping on the last
404 * close because it may cause a error when we open this file
405 * again and get at least level II oplock.
406 */
407 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
408 set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
409 cifs_set_oplock_level(cifsi, 0);
410 }
411
412 spin_unlock(&tcon->open_file_lock);
413
414 oplock_break_cancelled = cancel_work_sync(&cifs_file->oplock_break);
415
416 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
417 struct TCP_Server_Info *server = tcon->ses->server;
418 unsigned int xid;
419
420 xid = get_xid();
421 if (server->ops->close)
422 server->ops->close(xid, tcon, &cifs_file->fid);
423 _free_xid(xid);
424 }
425
426 if (oplock_break_cancelled)
427 cifs_done_oplock_break(cifsi);
428
429 cifs_del_pending_open(&open);
430
431 /*
432 * Delete any outstanding lock records. We'll lose them when the file
433 * is closed anyway.
434 */
435 down_write(&cifsi->lock_sem);
436 list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
437 list_del(&li->llist);
438 cifs_del_lock_waiters(li);
439 kfree(li);
440 }
441 list_del(&cifs_file->llist->llist);
442 kfree(cifs_file->llist);
443 up_write(&cifsi->lock_sem);
444
445 cifs_put_tlink(cifs_file->tlink);
446 dput(cifs_file->dentry);
447 cifs_sb_deactive(sb);
448 kfree(cifs_file);
449 }
450
451 int cifs_open(struct inode *inode, struct file *file)
452
453 {
454 int rc = -EACCES;
455 unsigned int xid;
456 __u32 oplock;
457 struct cifs_sb_info *cifs_sb;
458 struct TCP_Server_Info *server;
459 struct cifs_tcon *tcon;
460 struct tcon_link *tlink;
461 struct cifsFileInfo *cfile = NULL;
462 char *full_path = NULL;
463 bool posix_open_ok = false;
464 struct cifs_fid fid;
465 struct cifs_pending_open open;
466
467 xid = get_xid();
468
469 cifs_sb = CIFS_SB(inode->i_sb);
470 tlink = cifs_sb_tlink(cifs_sb);
471 if (IS_ERR(tlink)) {
472 free_xid(xid);
473 return PTR_ERR(tlink);
474 }
475 tcon = tlink_tcon(tlink);
476 server = tcon->ses->server;
477
478 full_path = build_path_from_dentry(file_dentry(file));
479 if (full_path == NULL) {
480 rc = -ENOMEM;
481 goto out;
482 }
483
484 cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
485 inode, file->f_flags, full_path);
486
487 if (file->f_flags & O_DIRECT &&
488 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
489 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
490 file->f_op = &cifs_file_direct_nobrl_ops;
491 else
492 file->f_op = &cifs_file_direct_ops;
493 }
494
495 if (server->oplocks)
496 oplock = REQ_OPLOCK;
497 else
498 oplock = 0;
499
500 if (!tcon->broken_posix_open && tcon->unix_ext &&
501 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
502 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
503 /* can not refresh inode info since size could be stale */
504 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
505 cifs_sb->mnt_file_mode /* ignored */,
506 file->f_flags, &oplock, &fid.netfid, xid);
507 if (rc == 0) {
508 cifs_dbg(FYI, "posix open succeeded\n");
509 posix_open_ok = true;
510 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
511 if (tcon->ses->serverNOS)
512 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",
513 tcon->ses->serverName,
514 tcon->ses->serverNOS);
515 tcon->broken_posix_open = true;
516 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
517 (rc != -EOPNOTSUPP)) /* path not found or net err */
518 goto out;
519 /*
520 * Else fallthrough to retry open the old way on network i/o
521 * or DFS errors.
522 */
523 }
524
525 if (server->ops->get_lease_key)
526 server->ops->get_lease_key(inode, &fid);
527
528 cifs_add_pending_open(&fid, tlink, &open);
529
530 if (!posix_open_ok) {
531 if (server->ops->get_lease_key)
532 server->ops->get_lease_key(inode, &fid);
533
534 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
535 file->f_flags, &oplock, &fid, xid);
536 if (rc) {
537 cifs_del_pending_open(&open);
538 goto out;
539 }
540 }
541
542 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
543 if (cfile == NULL) {
544 if (server->ops->close)
545 server->ops->close(xid, tcon, &fid);
546 cifs_del_pending_open(&open);
547 rc = -ENOMEM;
548 goto out;
549 }
550
551 cifs_fscache_set_inode_cookie(inode, file);
552
553 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
554 /*
555 * Time to set mode which we can not set earlier due to
556 * problems creating new read-only files.
557 */
558 struct cifs_unix_set_info_args args = {
559 .mode = inode->i_mode,
560 .uid = INVALID_UID, /* no change */
561 .gid = INVALID_GID, /* no change */
562 .ctime = NO_CHANGE_64,
563 .atime = NO_CHANGE_64,
564 .mtime = NO_CHANGE_64,
565 .device = 0,
566 };
567 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
568 cfile->pid);
569 }
570
571 out:
572 kfree(full_path);
573 free_xid(xid);
574 cifs_put_tlink(tlink);
575 return rc;
576 }
577
578 static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
579
580 /*
581 * Try to reacquire byte range locks that were released when session
582 * to server was lost.
583 */
584 static int
585 cifs_relock_file(struct cifsFileInfo *cfile)
586 {
587 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
588 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
589 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
590 int rc = 0;
591
592 down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING);
593 if (cinode->can_cache_brlcks) {
594 /* can cache locks - no need to relock */
595 up_read(&cinode->lock_sem);
596 return rc;
597 }
598
599 if (cap_unix(tcon->ses) &&
600 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
601 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
602 rc = cifs_push_posix_locks(cfile);
603 else
604 rc = tcon->ses->server->ops->push_mand_locks(cfile);
605
606 up_read(&cinode->lock_sem);
607 return rc;
608 }
609
610 static int
611 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
612 {
613 int rc = -EACCES;
614 unsigned int xid;
615 __u32 oplock;
616 struct cifs_sb_info *cifs_sb;
617 struct cifs_tcon *tcon;
618 struct TCP_Server_Info *server;
619 struct cifsInodeInfo *cinode;
620 struct inode *inode;
621 char *full_path = NULL;
622 int desired_access;
623 int disposition = FILE_OPEN;
624 int create_options = CREATE_NOT_DIR;
625 struct cifs_open_parms oparms;
626
627 xid = get_xid();
628 mutex_lock(&cfile->fh_mutex);
629 if (!cfile->invalidHandle) {
630 mutex_unlock(&cfile->fh_mutex);
631 rc = 0;
632 free_xid(xid);
633 return rc;
634 }
635
636 inode = d_inode(cfile->dentry);
637 cifs_sb = CIFS_SB(inode->i_sb);
638 tcon = tlink_tcon(cfile->tlink);
639 server = tcon->ses->server;
640
641 /*
642 * Can not grab rename sem here because various ops, including those
643 * that already have the rename sem can end up causing writepage to get
644 * called and if the server was down that means we end up here, and we
645 * can never tell if the caller already has the rename_sem.
646 */
647 full_path = build_path_from_dentry(cfile->dentry);
648 if (full_path == NULL) {
649 rc = -ENOMEM;
650 mutex_unlock(&cfile->fh_mutex);
651 free_xid(xid);
652 return rc;
653 }
654
655 cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
656 inode, cfile->f_flags, full_path);
657
658 if (tcon->ses->server->oplocks)
659 oplock = REQ_OPLOCK;
660 else
661 oplock = 0;
662
663 if (tcon->unix_ext && cap_unix(tcon->ses) &&
664 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
665 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
666 /*
667 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
668 * original open. Must mask them off for a reopen.
669 */
670 unsigned int oflags = cfile->f_flags &
671 ~(O_CREAT | O_EXCL | O_TRUNC);
672
673 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
674 cifs_sb->mnt_file_mode /* ignored */,
675 oflags, &oplock, &cfile->fid.netfid, xid);
676 if (rc == 0) {
677 cifs_dbg(FYI, "posix reopen succeeded\n");
678 oparms.reconnect = true;
679 goto reopen_success;
680 }
681 /*
682 * fallthrough to retry open the old way on errors, especially
683 * in the reconnect path it is important to retry hard
684 */
685 }
686
687 desired_access = cifs_convert_flags(cfile->f_flags);
688
689 if (backup_cred(cifs_sb))
690 create_options |= CREATE_OPEN_BACKUP_INTENT;
691
692 if (server->ops->get_lease_key)
693 server->ops->get_lease_key(inode, &cfile->fid);
694
695 oparms.tcon = tcon;
696 oparms.cifs_sb = cifs_sb;
697 oparms.desired_access = desired_access;
698 oparms.create_options = create_options;
699 oparms.disposition = disposition;
700 oparms.path = full_path;
701 oparms.fid = &cfile->fid;
702 oparms.reconnect = true;
703
704 /*
705 * Can not refresh inode by passing in file_info buf to be returned by
706 * ops->open and then calling get_inode_info with returned buf since
707 * file might have write behind data that needs to be flushed and server
708 * version of file size can be stale. If we knew for sure that inode was
709 * not dirty locally we could do this.
710 */
711 rc = server->ops->open(xid, &oparms, &oplock, NULL);
712 if (rc == -ENOENT && oparms.reconnect == false) {
713 /* durable handle timeout is expired - open the file again */
714 rc = server->ops->open(xid, &oparms, &oplock, NULL);
715 /* indicate that we need to relock the file */
716 oparms.reconnect = true;
717 }
718
719 if (rc) {
720 mutex_unlock(&cfile->fh_mutex);
721 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
722 cifs_dbg(FYI, "oplock: %d\n", oplock);
723 goto reopen_error_exit;
724 }
725
726 reopen_success:
727 cfile->invalidHandle = false;
728 mutex_unlock(&cfile->fh_mutex);
729 cinode = CIFS_I(inode);
730
731 if (can_flush) {
732 rc = filemap_write_and_wait(inode->i_mapping);
733 mapping_set_error(inode->i_mapping, rc);
734
735 if (tcon->unix_ext)
736 rc = cifs_get_inode_info_unix(&inode, full_path,
737 inode->i_sb, xid);
738 else
739 rc = cifs_get_inode_info(&inode, full_path, NULL,
740 inode->i_sb, xid, NULL);
741 }
742 /*
743 * Else we are writing out data to server already and could deadlock if
744 * we tried to flush data, and since we do not know if we have data that
745 * would invalidate the current end of file on the server we can not go
746 * to the server to get the new inode info.
747 */
748
749 /*
750 * If the server returned a read oplock and we have mandatory brlocks,
751 * set oplock level to None.
752 */
753 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
754 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
755 oplock = 0;
756 }
757
758 server->ops->set_fid(cfile, &cfile->fid, oplock);
759 if (oparms.reconnect)
760 cifs_relock_file(cfile);
761
762 reopen_error_exit:
763 kfree(full_path);
764 free_xid(xid);
765 return rc;
766 }
767
768 int cifs_close(struct inode *inode, struct file *file)
769 {
770 if (file->private_data != NULL) {
771 cifsFileInfo_put(file->private_data);
772 file->private_data = NULL;
773 }
774
775 /* return code from the ->release op is always ignored */
776 return 0;
777 }
778
779 void
780 cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
781 {
782 struct cifsFileInfo *open_file;
783 struct list_head *tmp;
784 struct list_head *tmp1;
785 struct list_head tmp_list;
786
787 if (!tcon->use_persistent || !tcon->need_reopen_files)
788 return;
789
790 tcon->need_reopen_files = false;
791
792 cifs_dbg(FYI, "Reopen persistent handles");
793 INIT_LIST_HEAD(&tmp_list);
794
795 /* list all files open on tree connection, reopen resilient handles */
796 spin_lock(&tcon->open_file_lock);
797 list_for_each(tmp, &tcon->openFileList) {
798 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
799 if (!open_file->invalidHandle)
800 continue;
801 cifsFileInfo_get(open_file);
802 list_add_tail(&open_file->rlist, &tmp_list);
803 }
804 spin_unlock(&tcon->open_file_lock);
805
806 list_for_each_safe(tmp, tmp1, &tmp_list) {
807 open_file = list_entry(tmp, struct cifsFileInfo, rlist);
808 if (cifs_reopen_file(open_file, false /* do not flush */))
809 tcon->need_reopen_files = true;
810 list_del_init(&open_file->rlist);
811 cifsFileInfo_put(open_file);
812 }
813 }
814
815 int cifs_closedir(struct inode *inode, struct file *file)
816 {
817 int rc = 0;
818 unsigned int xid;
819 struct cifsFileInfo *cfile = file->private_data;
820 struct cifs_tcon *tcon;
821 struct TCP_Server_Info *server;
822 char *buf;
823
824 cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
825
826 if (cfile == NULL)
827 return rc;
828
829 xid = get_xid();
830 tcon = tlink_tcon(cfile->tlink);
831 server = tcon->ses->server;
832
833 cifs_dbg(FYI, "Freeing private data in close dir\n");
834 spin_lock(&cfile->file_info_lock);
835 if (server->ops->dir_needs_close(cfile)) {
836 cfile->invalidHandle = true;
837 spin_unlock(&cfile->file_info_lock);
838 if (server->ops->close_dir)
839 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
840 else
841 rc = -ENOSYS;
842 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
843 /* not much we can do if it fails anyway, ignore rc */
844 rc = 0;
845 } else
846 spin_unlock(&cfile->file_info_lock);
847
848 buf = cfile->srch_inf.ntwrk_buf_start;
849 if (buf) {
850 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
851 cfile->srch_inf.ntwrk_buf_start = NULL;
852 if (cfile->srch_inf.smallBuf)
853 cifs_small_buf_release(buf);
854 else
855 cifs_buf_release(buf);
856 }
857
858 cifs_put_tlink(cfile->tlink);
859 kfree(file->private_data);
860 file->private_data = NULL;
861 /* BB can we lock the filestruct while this is going on? */
862 free_xid(xid);
863 return rc;
864 }
865
866 static struct cifsLockInfo *
867 cifs_lock_init(__u64 offset, __u64 length, __u8 type)
868 {
869 struct cifsLockInfo *lock =
870 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
871 if (!lock)
872 return lock;
873 lock->offset = offset;
874 lock->length = length;
875 lock->type = type;
876 lock->pid = current->tgid;
877 INIT_LIST_HEAD(&lock->blist);
878 init_waitqueue_head(&lock->block_q);
879 return lock;
880 }
881
882 void
883 cifs_del_lock_waiters(struct cifsLockInfo *lock)
884 {
885 struct cifsLockInfo *li, *tmp;
886 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
887 list_del_init(&li->blist);
888 wake_up(&li->block_q);
889 }
890 }
891
892 #define CIFS_LOCK_OP 0
893 #define CIFS_READ_OP 1
894 #define CIFS_WRITE_OP 2
895
896 /* @rw_check : 0 - no op, 1 - read, 2 - write */
897 static bool
898 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
899 __u64 length, __u8 type, struct cifsFileInfo *cfile,
900 struct cifsLockInfo **conf_lock, int rw_check)
901 {
902 struct cifsLockInfo *li;
903 struct cifsFileInfo *cur_cfile = fdlocks->cfile;
904 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
905
906 list_for_each_entry(li, &fdlocks->locks, llist) {
907 if (offset + length <= li->offset ||
908 offset >= li->offset + li->length)
909 continue;
910 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
911 server->ops->compare_fids(cfile, cur_cfile)) {
912 /* shared lock prevents write op through the same fid */
913 if (!(li->type & server->vals->shared_lock_type) ||
914 rw_check != CIFS_WRITE_OP)
915 continue;
916 }
917 if ((type & server->vals->shared_lock_type) &&
918 ((server->ops->compare_fids(cfile, cur_cfile) &&
919 current->tgid == li->pid) || type == li->type))
920 continue;
921 if (conf_lock)
922 *conf_lock = li;
923 return true;
924 }
925 return false;
926 }
927
928 bool
929 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
930 __u8 type, struct cifsLockInfo **conf_lock,
931 int rw_check)
932 {
933 bool rc = false;
934 struct cifs_fid_locks *cur;
935 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
936
937 list_for_each_entry(cur, &cinode->llist, llist) {
938 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
939 cfile, conf_lock, rw_check);
940 if (rc)
941 break;
942 }
943
944 return rc;
945 }
946
947 /*
948 * Check if there is another lock that prevents us to set the lock (mandatory
949 * style). If such a lock exists, update the flock structure with its
950 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
951 * or leave it the same if we can't. Returns 0 if we don't need to request to
952 * the server or 1 otherwise.
953 */
954 static int
955 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
956 __u8 type, struct file_lock *flock)
957 {
958 int rc = 0;
959 struct cifsLockInfo *conf_lock;
960 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
961 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
962 bool exist;
963
964 down_read(&cinode->lock_sem);
965
966 exist = cifs_find_lock_conflict(cfile, offset, length, type,
967 &conf_lock, CIFS_LOCK_OP);
968 if (exist) {
969 flock->fl_start = conf_lock->offset;
970 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
971 flock->fl_pid = conf_lock->pid;
972 if (conf_lock->type & server->vals->shared_lock_type)
973 flock->fl_type = F_RDLCK;
974 else
975 flock->fl_type = F_WRLCK;
976 } else if (!cinode->can_cache_brlcks)
977 rc = 1;
978 else
979 flock->fl_type = F_UNLCK;
980
981 up_read(&cinode->lock_sem);
982 return rc;
983 }
984
985 static void
986 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
987 {
988 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
989 down_write(&cinode->lock_sem);
990 list_add_tail(&lock->llist, &cfile->llist->locks);
991 up_write(&cinode->lock_sem);
992 }
993
994 /*
995 * Set the byte-range lock (mandatory style). Returns:
996 * 1) 0, if we set the lock and don't need to request to the server;
997 * 2) 1, if no locks prevent us but we need to request to the server;
998 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
999 */
1000 static int
1001 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
1002 bool wait)
1003 {
1004 struct cifsLockInfo *conf_lock;
1005 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1006 bool exist;
1007 int rc = 0;
1008
1009 try_again:
1010 exist = false;
1011 down_write(&cinode->lock_sem);
1012
1013 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1014 lock->type, &conf_lock, CIFS_LOCK_OP);
1015 if (!exist && cinode->can_cache_brlcks) {
1016 list_add_tail(&lock->llist, &cfile->llist->locks);
1017 up_write(&cinode->lock_sem);
1018 return rc;
1019 }
1020
1021 if (!exist)
1022 rc = 1;
1023 else if (!wait)
1024 rc = -EACCES;
1025 else {
1026 list_add_tail(&lock->blist, &conf_lock->blist);
1027 up_write(&cinode->lock_sem);
1028 rc = wait_event_interruptible(lock->block_q,
1029 (lock->blist.prev == &lock->blist) &&
1030 (lock->blist.next == &lock->blist));
1031 if (!rc)
1032 goto try_again;
1033 down_write(&cinode->lock_sem);
1034 list_del_init(&lock->blist);
1035 }
1036
1037 up_write(&cinode->lock_sem);
1038 return rc;
1039 }
1040
1041 /*
1042 * Check if there is another lock that prevents us to set the lock (posix
1043 * style). If such a lock exists, update the flock structure with its
1044 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1045 * or leave it the same if we can't. Returns 0 if we don't need to request to
1046 * the server or 1 otherwise.
1047 */
1048 static int
1049 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
1050 {
1051 int rc = 0;
1052 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1053 unsigned char saved_type = flock->fl_type;
1054
1055 if ((flock->fl_flags & FL_POSIX) == 0)
1056 return 1;
1057
1058 down_read(&cinode->lock_sem);
1059 posix_test_lock(file, flock);
1060
1061 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1062 flock->fl_type = saved_type;
1063 rc = 1;
1064 }
1065
1066 up_read(&cinode->lock_sem);
1067 return rc;
1068 }
1069
1070 /*
1071 * Set the byte-range lock (posix style). Returns:
1072 * 1) 0, if we set the lock and don't need to request to the server;
1073 * 2) 1, if we need to request to the server;
1074 * 3) <0, if the error occurs while setting the lock.
1075 */
1076 static int
1077 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1078 {
1079 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1080 int rc = 1;
1081
1082 if ((flock->fl_flags & FL_POSIX) == 0)
1083 return rc;
1084
1085 try_again:
1086 down_write(&cinode->lock_sem);
1087 if (!cinode->can_cache_brlcks) {
1088 up_write(&cinode->lock_sem);
1089 return rc;
1090 }
1091
1092 rc = posix_lock_file(file, flock, NULL);
1093 up_write(&cinode->lock_sem);
1094 if (rc == FILE_LOCK_DEFERRED) {
1095 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
1096 if (!rc)
1097 goto try_again;
1098 posix_unblock_lock(flock);
1099 }
1100 return rc;
1101 }
1102
1103 int
1104 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1105 {
1106 unsigned int xid;
1107 int rc = 0, stored_rc;
1108 struct cifsLockInfo *li, *tmp;
1109 struct cifs_tcon *tcon;
1110 unsigned int num, max_num, max_buf;
1111 LOCKING_ANDX_RANGE *buf, *cur;
1112 int types[] = {LOCKING_ANDX_LARGE_FILES,
1113 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1114 int i;
1115
1116 xid = get_xid();
1117 tcon = tlink_tcon(cfile->tlink);
1118
1119 /*
1120 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1121 * and check it for zero before using.
1122 */
1123 max_buf = tcon->ses->server->maxBuf;
1124 if (!max_buf) {
1125 free_xid(xid);
1126 return -EINVAL;
1127 }
1128
1129 max_num = (max_buf - sizeof(struct smb_hdr)) /
1130 sizeof(LOCKING_ANDX_RANGE);
1131 buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1132 if (!buf) {
1133 free_xid(xid);
1134 return -ENOMEM;
1135 }
1136
1137 for (i = 0; i < 2; i++) {
1138 cur = buf;
1139 num = 0;
1140 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1141 if (li->type != types[i])
1142 continue;
1143 cur->Pid = cpu_to_le16(li->pid);
1144 cur->LengthLow = cpu_to_le32((u32)li->length);
1145 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1146 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1147 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1148 if (++num == max_num) {
1149 stored_rc = cifs_lockv(xid, tcon,
1150 cfile->fid.netfid,
1151 (__u8)li->type, 0, num,
1152 buf);
1153 if (stored_rc)
1154 rc = stored_rc;
1155 cur = buf;
1156 num = 0;
1157 } else
1158 cur++;
1159 }
1160
1161 if (num) {
1162 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1163 (__u8)types[i], 0, num, buf);
1164 if (stored_rc)
1165 rc = stored_rc;
1166 }
1167 }
1168
1169 kfree(buf);
1170 free_xid(xid);
1171 return rc;
1172 }
1173
1174 static __u32
1175 hash_lockowner(fl_owner_t owner)
1176 {
1177 return cifs_lock_secret ^ hash32_ptr((const void *)owner);
1178 }
1179
1180 struct lock_to_push {
1181 struct list_head llist;
1182 __u64 offset;
1183 __u64 length;
1184 __u32 pid;
1185 __u16 netfid;
1186 __u8 type;
1187 };
1188
1189 static int
1190 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1191 {
1192 struct inode *inode = d_inode(cfile->dentry);
1193 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1194 struct file_lock *flock;
1195 struct file_lock_context *flctx = inode->i_flctx;
1196 unsigned int count = 0, i;
1197 int rc = 0, xid, type;
1198 struct list_head locks_to_send, *el;
1199 struct lock_to_push *lck, *tmp;
1200 __u64 length;
1201
1202 xid = get_xid();
1203
1204 if (!flctx)
1205 goto out;
1206
1207 spin_lock(&flctx->flc_lock);
1208 list_for_each(el, &flctx->flc_posix) {
1209 count++;
1210 }
1211 spin_unlock(&flctx->flc_lock);
1212
1213 INIT_LIST_HEAD(&locks_to_send);
1214
1215 /*
1216 * Allocating count locks is enough because no FL_POSIX locks can be
1217 * added to the list while we are holding cinode->lock_sem that
1218 * protects locking operations of this inode.
1219 */
1220 for (i = 0; i < count; i++) {
1221 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1222 if (!lck) {
1223 rc = -ENOMEM;
1224 goto err_out;
1225 }
1226 list_add_tail(&lck->llist, &locks_to_send);
1227 }
1228
1229 el = locks_to_send.next;
1230 spin_lock(&flctx->flc_lock);
1231 list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1232 if (el == &locks_to_send) {
1233 /*
1234 * The list ended. We don't have enough allocated
1235 * structures - something is really wrong.
1236 */
1237 cifs_dbg(VFS, "Can't push all brlocks!\n");
1238 break;
1239 }
1240 length = 1 + flock->fl_end - flock->fl_start;
1241 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1242 type = CIFS_RDLCK;
1243 else
1244 type = CIFS_WRLCK;
1245 lck = list_entry(el, struct lock_to_push, llist);
1246 lck->pid = hash_lockowner(flock->fl_owner);
1247 lck->netfid = cfile->fid.netfid;
1248 lck->length = length;
1249 lck->type = type;
1250 lck->offset = flock->fl_start;
1251 }
1252 spin_unlock(&flctx->flc_lock);
1253
1254 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1255 int stored_rc;
1256
1257 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1258 lck->offset, lck->length, NULL,
1259 lck->type, 0);
1260 if (stored_rc)
1261 rc = stored_rc;
1262 list_del(&lck->llist);
1263 kfree(lck);
1264 }
1265
1266 out:
1267 free_xid(xid);
1268 return rc;
1269 err_out:
1270 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1271 list_del(&lck->llist);
1272 kfree(lck);
1273 }
1274 goto out;
1275 }
1276
1277 static int
1278 cifs_push_locks(struct cifsFileInfo *cfile)
1279 {
1280 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1281 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1282 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1283 int rc = 0;
1284
1285 /* we are going to update can_cache_brlcks here - need a write access */
1286 down_write(&cinode->lock_sem);
1287 if (!cinode->can_cache_brlcks) {
1288 up_write(&cinode->lock_sem);
1289 return rc;
1290 }
1291
1292 if (cap_unix(tcon->ses) &&
1293 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1294 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1295 rc = cifs_push_posix_locks(cfile);
1296 else
1297 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1298
1299 cinode->can_cache_brlcks = false;
1300 up_write(&cinode->lock_sem);
1301 return rc;
1302 }
1303
1304 static void
1305 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1306 bool *wait_flag, struct TCP_Server_Info *server)
1307 {
1308 if (flock->fl_flags & FL_POSIX)
1309 cifs_dbg(FYI, "Posix\n");
1310 if (flock->fl_flags & FL_FLOCK)
1311 cifs_dbg(FYI, "Flock\n");
1312 if (flock->fl_flags & FL_SLEEP) {
1313 cifs_dbg(FYI, "Blocking lock\n");
1314 *wait_flag = true;
1315 }
1316 if (flock->fl_flags & FL_ACCESS)
1317 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1318 if (flock->fl_flags & FL_LEASE)
1319 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1320 if (flock->fl_flags &
1321 (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1322 FL_ACCESS | FL_LEASE | FL_CLOSE)))
1323 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1324
1325 *type = server->vals->large_lock_type;
1326 if (flock->fl_type == F_WRLCK) {
1327 cifs_dbg(FYI, "F_WRLCK\n");
1328 *type |= server->vals->exclusive_lock_type;
1329 *lock = 1;
1330 } else if (flock->fl_type == F_UNLCK) {
1331 cifs_dbg(FYI, "F_UNLCK\n");
1332 *type |= server->vals->unlock_lock_type;
1333 *unlock = 1;
1334 /* Check if unlock includes more than one lock range */
1335 } else if (flock->fl_type == F_RDLCK) {
1336 cifs_dbg(FYI, "F_RDLCK\n");
1337 *type |= server->vals->shared_lock_type;
1338 *lock = 1;
1339 } else if (flock->fl_type == F_EXLCK) {
1340 cifs_dbg(FYI, "F_EXLCK\n");
1341 *type |= server->vals->exclusive_lock_type;
1342 *lock = 1;
1343 } else if (flock->fl_type == F_SHLCK) {
1344 cifs_dbg(FYI, "F_SHLCK\n");
1345 *type |= server->vals->shared_lock_type;
1346 *lock = 1;
1347 } else
1348 cifs_dbg(FYI, "Unknown type of lock\n");
1349 }
1350
1351 static int
1352 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1353 bool wait_flag, bool posix_lck, unsigned int xid)
1354 {
1355 int rc = 0;
1356 __u64 length = 1 + flock->fl_end - flock->fl_start;
1357 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1358 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1359 struct TCP_Server_Info *server = tcon->ses->server;
1360 __u16 netfid = cfile->fid.netfid;
1361
1362 if (posix_lck) {
1363 int posix_lock_type;
1364
1365 rc = cifs_posix_lock_test(file, flock);
1366 if (!rc)
1367 return rc;
1368
1369 if (type & server->vals->shared_lock_type)
1370 posix_lock_type = CIFS_RDLCK;
1371 else
1372 posix_lock_type = CIFS_WRLCK;
1373 rc = CIFSSMBPosixLock(xid, tcon, netfid,
1374 hash_lockowner(flock->fl_owner),
1375 flock->fl_start, length, flock,
1376 posix_lock_type, wait_flag);
1377 return rc;
1378 }
1379
1380 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1381 if (!rc)
1382 return rc;
1383
1384 /* BB we could chain these into one lock request BB */
1385 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1386 1, 0, false);
1387 if (rc == 0) {
1388 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1389 type, 0, 1, false);
1390 flock->fl_type = F_UNLCK;
1391 if (rc != 0)
1392 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1393 rc);
1394 return 0;
1395 }
1396
1397 if (type & server->vals->shared_lock_type) {
1398 flock->fl_type = F_WRLCK;
1399 return 0;
1400 }
1401
1402 type &= ~server->vals->exclusive_lock_type;
1403
1404 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1405 type | server->vals->shared_lock_type,
1406 1, 0, false);
1407 if (rc == 0) {
1408 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1409 type | server->vals->shared_lock_type, 0, 1, false);
1410 flock->fl_type = F_RDLCK;
1411 if (rc != 0)
1412 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1413 rc);
1414 } else
1415 flock->fl_type = F_WRLCK;
1416
1417 return 0;
1418 }
1419
1420 void
1421 cifs_move_llist(struct list_head *source, struct list_head *dest)
1422 {
1423 struct list_head *li, *tmp;
1424 list_for_each_safe(li, tmp, source)
1425 list_move(li, dest);
1426 }
1427
1428 void
1429 cifs_free_llist(struct list_head *llist)
1430 {
1431 struct cifsLockInfo *li, *tmp;
1432 list_for_each_entry_safe(li, tmp, llist, llist) {
1433 cifs_del_lock_waiters(li);
1434 list_del(&li->llist);
1435 kfree(li);
1436 }
1437 }
1438
1439 int
1440 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1441 unsigned int xid)
1442 {
1443 int rc = 0, stored_rc;
1444 int types[] = {LOCKING_ANDX_LARGE_FILES,
1445 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1446 unsigned int i;
1447 unsigned int max_num, num, max_buf;
1448 LOCKING_ANDX_RANGE *buf, *cur;
1449 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1450 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1451 struct cifsLockInfo *li, *tmp;
1452 __u64 length = 1 + flock->fl_end - flock->fl_start;
1453 struct list_head tmp_llist;
1454
1455 INIT_LIST_HEAD(&tmp_llist);
1456
1457 /*
1458 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1459 * and check it for zero before using.
1460 */
1461 max_buf = tcon->ses->server->maxBuf;
1462 if (!max_buf)
1463 return -EINVAL;
1464
1465 max_num = (max_buf - sizeof(struct smb_hdr)) /
1466 sizeof(LOCKING_ANDX_RANGE);
1467 buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1468 if (!buf)
1469 return -ENOMEM;
1470
1471 down_write(&cinode->lock_sem);
1472 for (i = 0; i < 2; i++) {
1473 cur = buf;
1474 num = 0;
1475 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1476 if (flock->fl_start > li->offset ||
1477 (flock->fl_start + length) <
1478 (li->offset + li->length))
1479 continue;
1480 if (current->tgid != li->pid)
1481 continue;
1482 if (types[i] != li->type)
1483 continue;
1484 if (cinode->can_cache_brlcks) {
1485 /*
1486 * We can cache brlock requests - simply remove
1487 * a lock from the file's list.
1488 */
1489 list_del(&li->llist);
1490 cifs_del_lock_waiters(li);
1491 kfree(li);
1492 continue;
1493 }
1494 cur->Pid = cpu_to_le16(li->pid);
1495 cur->LengthLow = cpu_to_le32((u32)li->length);
1496 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1497 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1498 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1499 /*
1500 * We need to save a lock here to let us add it again to
1501 * the file's list if the unlock range request fails on
1502 * the server.
1503 */
1504 list_move(&li->llist, &tmp_llist);
1505 if (++num == max_num) {
1506 stored_rc = cifs_lockv(xid, tcon,
1507 cfile->fid.netfid,
1508 li->type, num, 0, buf);
1509 if (stored_rc) {
1510 /*
1511 * We failed on the unlock range
1512 * request - add all locks from the tmp
1513 * list to the head of the file's list.
1514 */
1515 cifs_move_llist(&tmp_llist,
1516 &cfile->llist->locks);
1517 rc = stored_rc;
1518 } else
1519 /*
1520 * The unlock range request succeed -
1521 * free the tmp list.
1522 */
1523 cifs_free_llist(&tmp_llist);
1524 cur = buf;
1525 num = 0;
1526 } else
1527 cur++;
1528 }
1529 if (num) {
1530 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1531 types[i], num, 0, buf);
1532 if (stored_rc) {
1533 cifs_move_llist(&tmp_llist,
1534 &cfile->llist->locks);
1535 rc = stored_rc;
1536 } else
1537 cifs_free_llist(&tmp_llist);
1538 }
1539 }
1540
1541 up_write(&cinode->lock_sem);
1542 kfree(buf);
1543 return rc;
1544 }
1545
1546 static int
1547 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1548 bool wait_flag, bool posix_lck, int lock, int unlock,
1549 unsigned int xid)
1550 {
1551 int rc = 0;
1552 __u64 length = 1 + flock->fl_end - flock->fl_start;
1553 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1554 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1555 struct TCP_Server_Info *server = tcon->ses->server;
1556 struct inode *inode = d_inode(cfile->dentry);
1557
1558 if (posix_lck) {
1559 int posix_lock_type;
1560
1561 rc = cifs_posix_lock_set(file, flock);
1562 if (!rc || rc < 0)
1563 return rc;
1564
1565 if (type & server->vals->shared_lock_type)
1566 posix_lock_type = CIFS_RDLCK;
1567 else
1568 posix_lock_type = CIFS_WRLCK;
1569
1570 if (unlock == 1)
1571 posix_lock_type = CIFS_UNLCK;
1572
1573 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1574 hash_lockowner(flock->fl_owner),
1575 flock->fl_start, length,
1576 NULL, posix_lock_type, wait_flag);
1577 goto out;
1578 }
1579
1580 if (lock) {
1581 struct cifsLockInfo *lock;
1582
1583 lock = cifs_lock_init(flock->fl_start, length, type);
1584 if (!lock)
1585 return -ENOMEM;
1586
1587 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1588 if (rc < 0) {
1589 kfree(lock);
1590 return rc;
1591 }
1592 if (!rc)
1593 goto out;
1594
1595 /*
1596 * Windows 7 server can delay breaking lease from read to None
1597 * if we set a byte-range lock on a file - break it explicitly
1598 * before sending the lock to the server to be sure the next
1599 * read won't conflict with non-overlapted locks due to
1600 * pagereading.
1601 */
1602 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1603 CIFS_CACHE_READ(CIFS_I(inode))) {
1604 cifs_zap_mapping(inode);
1605 cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1606 inode);
1607 CIFS_I(inode)->oplock = 0;
1608 }
1609
1610 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1611 type, 1, 0, wait_flag);
1612 if (rc) {
1613 kfree(lock);
1614 return rc;
1615 }
1616
1617 cifs_lock_add(cfile, lock);
1618 } else if (unlock)
1619 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1620
1621 out:
1622 if (flock->fl_flags & FL_POSIX && !rc)
1623 rc = locks_lock_file_wait(file, flock);
1624 return rc;
1625 }
1626
1627 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1628 {
1629 int rc, xid;
1630 int lock = 0, unlock = 0;
1631 bool wait_flag = false;
1632 bool posix_lck = false;
1633 struct cifs_sb_info *cifs_sb;
1634 struct cifs_tcon *tcon;
1635 struct cifsInodeInfo *cinode;
1636 struct cifsFileInfo *cfile;
1637 __u16 netfid;
1638 __u32 type;
1639
1640 rc = -EACCES;
1641 xid = get_xid();
1642
1643 cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1644 cmd, flock->fl_flags, flock->fl_type,
1645 flock->fl_start, flock->fl_end);
1646
1647 cfile = (struct cifsFileInfo *)file->private_data;
1648 tcon = tlink_tcon(cfile->tlink);
1649
1650 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1651 tcon->ses->server);
1652
1653 cifs_sb = CIFS_FILE_SB(file);
1654 netfid = cfile->fid.netfid;
1655 cinode = CIFS_I(file_inode(file));
1656
1657 if (cap_unix(tcon->ses) &&
1658 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1659 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1660 posix_lck = true;
1661 /*
1662 * BB add code here to normalize offset and length to account for
1663 * negative length which we can not accept over the wire.
1664 */
1665 if (IS_GETLK(cmd)) {
1666 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1667 free_xid(xid);
1668 return rc;
1669 }
1670
1671 if (!lock && !unlock) {
1672 /*
1673 * if no lock or unlock then nothing to do since we do not
1674 * know what it is
1675 */
1676 free_xid(xid);
1677 return -EOPNOTSUPP;
1678 }
1679
1680 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1681 xid);
1682 free_xid(xid);
1683 return rc;
1684 }
1685
1686 /*
1687 * update the file size (if needed) after a write. Should be called with
1688 * the inode->i_lock held
1689 */
1690 void
1691 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1692 unsigned int bytes_written)
1693 {
1694 loff_t end_of_write = offset + bytes_written;
1695
1696 if (end_of_write > cifsi->server_eof)
1697 cifsi->server_eof = end_of_write;
1698 }
1699
1700 static ssize_t
1701 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1702 size_t write_size, loff_t *offset)
1703 {
1704 int rc = 0;
1705 unsigned int bytes_written = 0;
1706 unsigned int total_written;
1707 struct cifs_sb_info *cifs_sb;
1708 struct cifs_tcon *tcon;
1709 struct TCP_Server_Info *server;
1710 unsigned int xid;
1711 struct dentry *dentry = open_file->dentry;
1712 struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1713 struct cifs_io_parms io_parms;
1714
1715 cifs_sb = CIFS_SB(dentry->d_sb);
1716
1717 cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
1718 write_size, *offset, dentry);
1719
1720 tcon = tlink_tcon(open_file->tlink);
1721 server = tcon->ses->server;
1722
1723 if (!server->ops->sync_write)
1724 return -ENOSYS;
1725
1726 xid = get_xid();
1727
1728 for (total_written = 0; write_size > total_written;
1729 total_written += bytes_written) {
1730 rc = -EAGAIN;
1731 while (rc == -EAGAIN) {
1732 struct kvec iov[2];
1733 unsigned int len;
1734
1735 if (open_file->invalidHandle) {
1736 /* we could deadlock if we called
1737 filemap_fdatawait from here so tell
1738 reopen_file not to flush data to
1739 server now */
1740 rc = cifs_reopen_file(open_file, false);
1741 if (rc != 0)
1742 break;
1743 }
1744
1745 len = min(server->ops->wp_retry_size(d_inode(dentry)),
1746 (unsigned int)write_size - total_written);
1747 /* iov[0] is reserved for smb header */
1748 iov[1].iov_base = (char *)write_data + total_written;
1749 iov[1].iov_len = len;
1750 io_parms.pid = pid;
1751 io_parms.tcon = tcon;
1752 io_parms.offset = *offset;
1753 io_parms.length = len;
1754 rc = server->ops->sync_write(xid, &open_file->fid,
1755 &io_parms, &bytes_written, iov, 1);
1756 }
1757 if (rc || (bytes_written == 0)) {
1758 if (total_written)
1759 break;
1760 else {
1761 free_xid(xid);
1762 return rc;
1763 }
1764 } else {
1765 spin_lock(&d_inode(dentry)->i_lock);
1766 cifs_update_eof(cifsi, *offset, bytes_written);
1767 spin_unlock(&d_inode(dentry)->i_lock);
1768 *offset += bytes_written;
1769 }
1770 }
1771
1772 cifs_stats_bytes_written(tcon, total_written);
1773
1774 if (total_written > 0) {
1775 spin_lock(&d_inode(dentry)->i_lock);
1776 if (*offset > d_inode(dentry)->i_size)
1777 i_size_write(d_inode(dentry), *offset);
1778 spin_unlock(&d_inode(dentry)->i_lock);
1779 }
1780 mark_inode_dirty_sync(d_inode(dentry));
1781 free_xid(xid);
1782 return total_written;
1783 }
1784
1785 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1786 bool fsuid_only)
1787 {
1788 struct cifsFileInfo *open_file = NULL;
1789 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1790 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1791
1792 /* only filter by fsuid on multiuser mounts */
1793 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1794 fsuid_only = false;
1795
1796 spin_lock(&tcon->open_file_lock);
1797 /* we could simply get the first_list_entry since write-only entries
1798 are always at the end of the list but since the first entry might
1799 have a close pending, we go through the whole list */
1800 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1801 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1802 continue;
1803 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1804 if (!open_file->invalidHandle) {
1805 /* found a good file */
1806 /* lock it so it will not be closed on us */
1807 cifsFileInfo_get(open_file);
1808 spin_unlock(&tcon->open_file_lock);
1809 return open_file;
1810 } /* else might as well continue, and look for
1811 another, or simply have the caller reopen it
1812 again rather than trying to fix this handle */
1813 } else /* write only file */
1814 break; /* write only files are last so must be done */
1815 }
1816 spin_unlock(&tcon->open_file_lock);
1817 return NULL;
1818 }
1819
1820 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1821 bool fsuid_only)
1822 {
1823 struct cifsFileInfo *open_file, *inv_file = NULL;
1824 struct cifs_sb_info *cifs_sb;
1825 struct cifs_tcon *tcon;
1826 bool any_available = false;
1827 int rc;
1828 unsigned int refind = 0;
1829
1830 /* Having a null inode here (because mapping->host was set to zero by
1831 the VFS or MM) should not happen but we had reports of on oops (due to
1832 it being zero) during stress testcases so we need to check for it */
1833
1834 if (cifs_inode == NULL) {
1835 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1836 dump_stack();
1837 return NULL;
1838 }
1839
1840 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1841 tcon = cifs_sb_master_tcon(cifs_sb);
1842
1843 /* only filter by fsuid on multiuser mounts */
1844 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1845 fsuid_only = false;
1846
1847 spin_lock(&tcon->open_file_lock);
1848 refind_writable:
1849 if (refind > MAX_REOPEN_ATT) {
1850 spin_unlock(&tcon->open_file_lock);
1851 return NULL;
1852 }
1853 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1854 if (!any_available && open_file->pid != current->tgid)
1855 continue;
1856 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1857 continue;
1858 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1859 if (!open_file->invalidHandle) {
1860 /* found a good writable file */
1861 cifsFileInfo_get(open_file);
1862 spin_unlock(&tcon->open_file_lock);
1863 return open_file;
1864 } else {
1865 if (!inv_file)
1866 inv_file = open_file;
1867 }
1868 }
1869 }
1870 /* couldn't find useable FH with same pid, try any available */
1871 if (!any_available) {
1872 any_available = true;
1873 goto refind_writable;
1874 }
1875
1876 if (inv_file) {
1877 any_available = false;
1878 cifsFileInfo_get(inv_file);
1879 }
1880
1881 spin_unlock(&tcon->open_file_lock);
1882
1883 if (inv_file) {
1884 rc = cifs_reopen_file(inv_file, false);
1885 if (!rc)
1886 return inv_file;
1887 else {
1888 spin_lock(&tcon->open_file_lock);
1889 list_move_tail(&inv_file->flist,
1890 &cifs_inode->openFileList);
1891 spin_unlock(&tcon->open_file_lock);
1892 cifsFileInfo_put(inv_file);
1893 ++refind;
1894 inv_file = NULL;
1895 spin_lock(&tcon->open_file_lock);
1896 goto refind_writable;
1897 }
1898 }
1899
1900 return NULL;
1901 }
1902
1903 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1904 {
1905 struct address_space *mapping = page->mapping;
1906 loff_t offset = (loff_t)page->index << PAGE_SHIFT;
1907 char *write_data;
1908 int rc = -EFAULT;
1909 int bytes_written = 0;
1910 struct inode *inode;
1911 struct cifsFileInfo *open_file;
1912
1913 if (!mapping || !mapping->host)
1914 return -EFAULT;
1915
1916 inode = page->mapping->host;
1917
1918 offset += (loff_t)from;
1919 write_data = kmap(page);
1920 write_data += from;
1921
1922 if ((to > PAGE_SIZE) || (from > to)) {
1923 kunmap(page);
1924 return -EIO;
1925 }
1926
1927 /* racing with truncate? */
1928 if (offset > mapping->host->i_size) {
1929 kunmap(page);
1930 return 0; /* don't care */
1931 }
1932
1933 /* check to make sure that we are not extending the file */
1934 if (mapping->host->i_size - offset < (loff_t)to)
1935 to = (unsigned)(mapping->host->i_size - offset);
1936
1937 open_file = find_writable_file(CIFS_I(mapping->host), false);
1938 if (open_file) {
1939 bytes_written = cifs_write(open_file, open_file->pid,
1940 write_data, to - from, &offset);
1941 cifsFileInfo_put(open_file);
1942 /* Does mm or vfs already set times? */
1943 inode->i_atime = inode->i_mtime = current_time(inode);
1944 if ((bytes_written > 0) && (offset))
1945 rc = 0;
1946 else if (bytes_written < 0)
1947 rc = bytes_written;
1948 } else {
1949 cifs_dbg(FYI, "No writeable filehandles for inode\n");
1950 rc = -EIO;
1951 }
1952
1953 kunmap(page);
1954 return rc;
1955 }
1956
1957 static struct cifs_writedata *
1958 wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
1959 pgoff_t end, pgoff_t *index,
1960 unsigned int *found_pages)
1961 {
1962 unsigned int nr_pages;
1963 struct page **pages;
1964 struct cifs_writedata *wdata;
1965
1966 wdata = cifs_writedata_alloc((unsigned int)tofind,
1967 cifs_writev_complete);
1968 if (!wdata)
1969 return NULL;
1970
1971 /*
1972 * find_get_pages_tag seems to return a max of 256 on each
1973 * iteration, so we must call it several times in order to
1974 * fill the array or the wsize is effectively limited to
1975 * 256 * PAGE_SIZE.
1976 */
1977 *found_pages = 0;
1978 pages = wdata->pages;
1979 do {
1980 nr_pages = find_get_pages_tag(mapping, index,
1981 PAGECACHE_TAG_DIRTY, tofind,
1982 pages);
1983 *found_pages += nr_pages;
1984 tofind -= nr_pages;
1985 pages += nr_pages;
1986 } while (nr_pages && tofind && *index <= end);
1987
1988 return wdata;
1989 }
1990
1991 static unsigned int
1992 wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
1993 struct address_space *mapping,
1994 struct writeback_control *wbc,
1995 pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
1996 {
1997 unsigned int nr_pages = 0, i;
1998 struct page *page;
1999
2000 for (i = 0; i < found_pages; i++) {
2001 page = wdata->pages[i];
2002 /*
2003 * At this point we hold neither mapping->tree_lock nor
2004 * lock on the page itself: the page may be truncated or
2005 * invalidated (changing page->mapping to NULL), or even
2006 * swizzled back from swapper_space to tmpfs file
2007 * mapping
2008 */
2009
2010 if (nr_pages == 0)
2011 lock_page(page);
2012 else if (!trylock_page(page))
2013 break;
2014
2015 if (unlikely(page->mapping != mapping)) {
2016 unlock_page(page);
2017 break;
2018 }
2019
2020 if (!wbc->range_cyclic && page->index > end) {
2021 *done = true;
2022 unlock_page(page);
2023 break;
2024 }
2025
2026 if (*next && (page->index != *next)) {
2027 /* Not next consecutive page */
2028 unlock_page(page);
2029 break;
2030 }
2031
2032 if (wbc->sync_mode != WB_SYNC_NONE)
2033 wait_on_page_writeback(page);
2034
2035 if (PageWriteback(page) ||
2036 !clear_page_dirty_for_io(page)) {
2037 unlock_page(page);
2038 break;
2039 }
2040
2041 /*
2042 * This actually clears the dirty bit in the radix tree.
2043 * See cifs_writepage() for more commentary.
2044 */
2045 set_page_writeback(page);
2046 if (page_offset(page) >= i_size_read(mapping->host)) {
2047 *done = true;
2048 unlock_page(page);
2049 end_page_writeback(page);
2050 break;
2051 }
2052
2053 wdata->pages[i] = page;
2054 *next = page->index + 1;
2055 ++nr_pages;
2056 }
2057
2058 /* reset index to refind any pages skipped */
2059 if (nr_pages == 0)
2060 *index = wdata->pages[0]->index + 1;
2061
2062 /* put any pages we aren't going to use */
2063 for (i = nr_pages; i < found_pages; i++) {
2064 put_page(wdata->pages[i]);
2065 wdata->pages[i] = NULL;
2066 }
2067
2068 return nr_pages;
2069 }
2070
2071 static int
2072 wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2073 struct address_space *mapping, struct writeback_control *wbc)
2074 {
2075 int rc = 0;
2076 struct TCP_Server_Info *server;
2077 unsigned int i;
2078
2079 wdata->sync_mode = wbc->sync_mode;
2080 wdata->nr_pages = nr_pages;
2081 wdata->offset = page_offset(wdata->pages[0]);
2082 wdata->pagesz = PAGE_SIZE;
2083 wdata->tailsz = min(i_size_read(mapping->host) -
2084 page_offset(wdata->pages[nr_pages - 1]),
2085 (loff_t)PAGE_SIZE);
2086 wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2087
2088 if (wdata->cfile != NULL)
2089 cifsFileInfo_put(wdata->cfile);
2090 wdata->cfile = find_writable_file(CIFS_I(mapping->host), false);
2091 if (!wdata->cfile) {
2092 cifs_dbg(VFS, "No writable handles for inode\n");
2093 rc = -EBADF;
2094 } else {
2095 wdata->pid = wdata->cfile->pid;
2096 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2097 rc = server->ops->async_writev(wdata, cifs_writedata_release);
2098 }
2099
2100 for (i = 0; i < nr_pages; ++i)
2101 unlock_page(wdata->pages[i]);
2102
2103 return rc;
2104 }
2105
2106 static int cifs_writepages(struct address_space *mapping,
2107 struct writeback_control *wbc)
2108 {
2109 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
2110 struct TCP_Server_Info *server;
2111 bool done = false, scanned = false, range_whole = false;
2112 pgoff_t end, index;
2113 struct cifs_writedata *wdata;
2114 int rc = 0;
2115
2116 /*
2117 * If wsize is smaller than the page cache size, default to writing
2118 * one page at a time via cifs_writepage
2119 */
2120 if (cifs_sb->wsize < PAGE_SIZE)
2121 return generic_writepages(mapping, wbc);
2122
2123 if (wbc->range_cyclic) {
2124 index = mapping->writeback_index; /* Start from prev offset */
2125 end = -1;
2126 } else {
2127 index = wbc->range_start >> PAGE_SHIFT;
2128 end = wbc->range_end >> PAGE_SHIFT;
2129 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2130 range_whole = true;
2131 scanned = true;
2132 }
2133 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
2134 retry:
2135 while (!done && index <= end) {
2136 unsigned int i, nr_pages, found_pages, wsize, credits;
2137 pgoff_t next = 0, tofind, saved_index = index;
2138
2139 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2140 &wsize, &credits);
2141 if (rc)
2142 break;
2143
2144 tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2145
2146 wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2147 &found_pages);
2148 if (!wdata) {
2149 rc = -ENOMEM;
2150 add_credits_and_wake_if(server, credits, 0);
2151 break;
2152 }
2153
2154 if (found_pages == 0) {
2155 kref_put(&wdata->refcount, cifs_writedata_release);
2156 add_credits_and_wake_if(server, credits, 0);
2157 break;
2158 }
2159
2160 nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2161 end, &index, &next, &done);
2162
2163 /* nothing to write? */
2164 if (nr_pages == 0) {
2165 kref_put(&wdata->refcount, cifs_writedata_release);
2166 add_credits_and_wake_if(server, credits, 0);
2167 continue;
2168 }
2169
2170 wdata->credits = credits;
2171
2172 rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2173
2174 /* send failure -- clean up the mess */
2175 if (rc != 0) {
2176 add_credits_and_wake_if(server, wdata->credits, 0);
2177 for (i = 0; i < nr_pages; ++i) {
2178 if (rc == -EAGAIN)
2179 redirty_page_for_writepage(wbc,
2180 wdata->pages[i]);
2181 else
2182 SetPageError(wdata->pages[i]);
2183 end_page_writeback(wdata->pages[i]);
2184 put_page(wdata->pages[i]);
2185 }
2186 if (rc != -EAGAIN)
2187 mapping_set_error(mapping, rc);
2188 }
2189 kref_put(&wdata->refcount, cifs_writedata_release);
2190
2191 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2192 index = saved_index;
2193 continue;
2194 }
2195
2196 wbc->nr_to_write -= nr_pages;
2197 if (wbc->nr_to_write <= 0)
2198 done = true;
2199
2200 index = next;
2201 }
2202
2203 if (!scanned && !done) {
2204 /*
2205 * We hit the last page and there is more work to be done: wrap
2206 * back to the start of the file
2207 */
2208 scanned = true;
2209 index = 0;
2210 goto retry;
2211 }
2212
2213 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2214 mapping->writeback_index = index;
2215
2216 return rc;
2217 }
2218
2219 static int
2220 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2221 {
2222 int rc;
2223 unsigned int xid;
2224
2225 xid = get_xid();
2226 /* BB add check for wbc flags */
2227 get_page(page);
2228 if (!PageUptodate(page))
2229 cifs_dbg(FYI, "ppw - page not up to date\n");
2230
2231 /*
2232 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2233 *
2234 * A writepage() implementation always needs to do either this,
2235 * or re-dirty the page with "redirty_page_for_writepage()" in
2236 * the case of a failure.
2237 *
2238 * Just unlocking the page will cause the radix tree tag-bits
2239 * to fail to update with the state of the page correctly.
2240 */
2241 set_page_writeback(page);
2242 retry_write:
2243 rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2244 if (rc == -EAGAIN) {
2245 if (wbc->sync_mode == WB_SYNC_ALL)
2246 goto retry_write;
2247 redirty_page_for_writepage(wbc, page);
2248 } else if (rc != 0) {
2249 SetPageError(page);
2250 mapping_set_error(page->mapping, rc);
2251 } else {
2252 SetPageUptodate(page);
2253 }
2254 end_page_writeback(page);
2255 put_page(page);
2256 free_xid(xid);
2257 return rc;
2258 }
2259
2260 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2261 {
2262 int rc = cifs_writepage_locked(page, wbc);
2263 unlock_page(page);
2264 return rc;
2265 }
2266
2267 static int cifs_write_end(struct file *file, struct address_space *mapping,
2268 loff_t pos, unsigned len, unsigned copied,
2269 struct page *page, void *fsdata)
2270 {
2271 int rc;
2272 struct inode *inode = mapping->host;
2273 struct cifsFileInfo *cfile = file->private_data;
2274 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2275 __u32 pid;
2276
2277 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2278 pid = cfile->pid;
2279 else
2280 pid = current->tgid;
2281
2282 cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2283 page, pos, copied);
2284
2285 if (PageChecked(page)) {
2286 if (copied == len)
2287 SetPageUptodate(page);
2288 ClearPageChecked(page);
2289 } else if (!PageUptodate(page) && copied == PAGE_SIZE)
2290 SetPageUptodate(page);
2291
2292 if (!PageUptodate(page)) {
2293 char *page_data;
2294 unsigned offset = pos & (PAGE_SIZE - 1);
2295 unsigned int xid;
2296
2297 xid = get_xid();
2298 /* this is probably better than directly calling
2299 partialpage_write since in this function the file handle is
2300 known which we might as well leverage */
2301 /* BB check if anything else missing out of ppw
2302 such as updating last write time */
2303 page_data = kmap(page);
2304 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2305 /* if (rc < 0) should we set writebehind rc? */
2306 kunmap(page);
2307
2308 free_xid(xid);
2309 } else {
2310 rc = copied;
2311 pos += copied;
2312 set_page_dirty(page);
2313 }
2314
2315 if (rc > 0) {
2316 spin_lock(&inode->i_lock);
2317 if (pos > inode->i_size)
2318 i_size_write(inode, pos);
2319 spin_unlock(&inode->i_lock);
2320 }
2321
2322 unlock_page(page);
2323 put_page(page);
2324
2325 return rc;
2326 }
2327
2328 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2329 int datasync)
2330 {
2331 unsigned int xid;
2332 int rc = 0;
2333 struct cifs_tcon *tcon;
2334 struct TCP_Server_Info *server;
2335 struct cifsFileInfo *smbfile = file->private_data;
2336 struct inode *inode = file_inode(file);
2337 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2338
2339 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2340 if (rc)
2341 return rc;
2342 inode_lock(inode);
2343
2344 xid = get_xid();
2345
2346 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2347 file, datasync);
2348
2349 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2350 rc = cifs_zap_mapping(inode);
2351 if (rc) {
2352 cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2353 rc = 0; /* don't care about it in fsync */
2354 }
2355 }
2356
2357 tcon = tlink_tcon(smbfile->tlink);
2358 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2359 server = tcon->ses->server;
2360 if (server->ops->flush)
2361 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2362 else
2363 rc = -ENOSYS;
2364 }
2365
2366 free_xid(xid);
2367 inode_unlock(inode);
2368 return rc;
2369 }
2370
2371 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2372 {
2373 unsigned int xid;
2374 int rc = 0;
2375 struct cifs_tcon *tcon;
2376 struct TCP_Server_Info *server;
2377 struct cifsFileInfo *smbfile = file->private_data;
2378 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2379 struct inode *inode = file->f_mapping->host;
2380
2381 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2382 if (rc)
2383 return rc;
2384 inode_lock(inode);
2385
2386 xid = get_xid();
2387
2388 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2389 file, datasync);
2390
2391 tcon = tlink_tcon(smbfile->tlink);
2392 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2393 server = tcon->ses->server;
2394 if (server->ops->flush)
2395 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2396 else
2397 rc = -ENOSYS;
2398 }
2399
2400 free_xid(xid);
2401 inode_unlock(inode);
2402 return rc;
2403 }
2404
2405 /*
2406 * As file closes, flush all cached write data for this inode checking
2407 * for write behind errors.
2408 */
2409 int cifs_flush(struct file *file, fl_owner_t id)
2410 {
2411 struct inode *inode = file_inode(file);
2412 int rc = 0;
2413
2414 if (file->f_mode & FMODE_WRITE)
2415 rc = filemap_write_and_wait(inode->i_mapping);
2416
2417 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2418
2419 return rc;
2420 }
2421
2422 static int
2423 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2424 {
2425 int rc = 0;
2426 unsigned long i;
2427
2428 for (i = 0; i < num_pages; i++) {
2429 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2430 if (!pages[i]) {
2431 /*
2432 * save number of pages we have already allocated and
2433 * return with ENOMEM error
2434 */
2435 num_pages = i;
2436 rc = -ENOMEM;
2437 break;
2438 }
2439 }
2440
2441 if (rc) {
2442 for (i = 0; i < num_pages; i++)
2443 put_page(pages[i]);
2444 }
2445 return rc;
2446 }
2447
2448 static inline
2449 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2450 {
2451 size_t num_pages;
2452 size_t clen;
2453
2454 clen = min_t(const size_t, len, wsize);
2455 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2456
2457 if (cur_len)
2458 *cur_len = clen;
2459
2460 return num_pages;
2461 }
2462
2463 static void
2464 cifs_uncached_writedata_release(struct kref *refcount)
2465 {
2466 int i;
2467 struct cifs_writedata *wdata = container_of(refcount,
2468 struct cifs_writedata, refcount);
2469
2470 kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
2471 for (i = 0; i < wdata->nr_pages; i++)
2472 put_page(wdata->pages[i]);
2473 cifs_writedata_release(refcount);
2474 }
2475
2476 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);
2477
2478 static void
2479 cifs_uncached_writev_complete(struct work_struct *work)
2480 {
2481 struct cifs_writedata *wdata = container_of(work,
2482 struct cifs_writedata, work);
2483 struct inode *inode = d_inode(wdata->cfile->dentry);
2484 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2485
2486 spin_lock(&inode->i_lock);
2487 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2488 if (cifsi->server_eof > inode->i_size)
2489 i_size_write(inode, cifsi->server_eof);
2490 spin_unlock(&inode->i_lock);
2491
2492 complete(&wdata->done);
2493 collect_uncached_write_data(wdata->ctx);
2494 /* the below call can possibly free the last ref to aio ctx */
2495 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2496 }
2497
2498 static int
2499 wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2500 size_t *len, unsigned long *num_pages)
2501 {
2502 size_t save_len, copied, bytes, cur_len = *len;
2503 unsigned long i, nr_pages = *num_pages;
2504
2505 save_len = cur_len;
2506 for (i = 0; i < nr_pages; i++) {
2507 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2508 copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2509 cur_len -= copied;
2510 /*
2511 * If we didn't copy as much as we expected, then that
2512 * may mean we trod into an unmapped area. Stop copying
2513 * at that point. On the next pass through the big
2514 * loop, we'll likely end up getting a zero-length
2515 * write and bailing out of it.
2516 */
2517 if (copied < bytes)
2518 break;
2519 }
2520 cur_len = save_len - cur_len;
2521 *len = cur_len;
2522
2523 /*
2524 * If we have no data to send, then that probably means that
2525 * the copy above failed altogether. That's most likely because
2526 * the address in the iovec was bogus. Return -EFAULT and let
2527 * the caller free anything we allocated and bail out.
2528 */
2529 if (!cur_len)
2530 return -EFAULT;
2531
2532 /*
2533 * i + 1 now represents the number of pages we actually used in
2534 * the copy phase above.
2535 */
2536 *num_pages = i + 1;
2537 return 0;
2538 }
2539
2540 static int
2541 cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2542 struct cifsFileInfo *open_file,
2543 struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
2544 struct cifs_aio_ctx *ctx)
2545 {
2546 int rc = 0;
2547 size_t cur_len;
2548 unsigned long nr_pages, num_pages, i;
2549 struct cifs_writedata *wdata;
2550 struct iov_iter saved_from = *from;
2551 loff_t saved_offset = offset;
2552 pid_t pid;
2553 struct TCP_Server_Info *server;
2554
2555 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2556 pid = open_file->pid;
2557 else
2558 pid = current->tgid;
2559
2560 server = tlink_tcon(open_file->tlink)->ses->server;
2561
2562 do {
2563 unsigned int wsize, credits;
2564
2565 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2566 &wsize, &credits);
2567 if (rc)
2568 break;
2569
2570 nr_pages = get_numpages(wsize, len, &cur_len);
2571 wdata = cifs_writedata_alloc(nr_pages,
2572 cifs_uncached_writev_complete);
2573 if (!wdata) {
2574 rc = -ENOMEM;
2575 add_credits_and_wake_if(server, credits, 0);
2576 break;
2577 }
2578
2579 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2580 if (rc) {
2581 kfree(wdata);
2582 add_credits_and_wake_if(server, credits, 0);
2583 break;
2584 }
2585
2586 num_pages = nr_pages;
2587 rc = wdata_fill_from_iovec(wdata, from, &cur_len, &num_pages);
2588 if (rc) {
2589 for (i = 0; i < nr_pages; i++)
2590 put_page(wdata->pages[i]);
2591 kfree(wdata);
2592 add_credits_and_wake_if(server, credits, 0);
2593 break;
2594 }
2595
2596 /*
2597 * Bring nr_pages down to the number of pages we actually used,
2598 * and free any pages that we didn't use.
2599 */
2600 for ( ; nr_pages > num_pages; nr_pages--)
2601 put_page(wdata->pages[nr_pages - 1]);
2602
2603 wdata->sync_mode = WB_SYNC_ALL;
2604 wdata->nr_pages = nr_pages;
2605 wdata->offset = (__u64)offset;
2606 wdata->cfile = cifsFileInfo_get(open_file);
2607 wdata->pid = pid;
2608 wdata->bytes = cur_len;
2609 wdata->pagesz = PAGE_SIZE;
2610 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2611 wdata->credits = credits;
2612 wdata->ctx = ctx;
2613 kref_get(&ctx->refcount);
2614
2615 if (!wdata->cfile->invalidHandle ||
2616 !(rc = cifs_reopen_file(wdata->cfile, false)))
2617 rc = server->ops->async_writev(wdata,
2618 cifs_uncached_writedata_release);
2619 if (rc) {
2620 add_credits_and_wake_if(server, wdata->credits, 0);
2621 kref_put(&wdata->refcount,
2622 cifs_uncached_writedata_release);
2623 if (rc == -EAGAIN) {
2624 *from = saved_from;
2625 iov_iter_advance(from, offset - saved_offset);
2626 continue;
2627 }
2628 break;
2629 }
2630
2631 list_add_tail(&wdata->list, wdata_list);
2632 offset += cur_len;
2633 len -= cur_len;
2634 } while (len > 0);
2635
2636 return rc;
2637 }
2638
2639 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
2640 {
2641 struct cifs_writedata *wdata, *tmp;
2642 struct cifs_tcon *tcon;
2643 struct cifs_sb_info *cifs_sb;
2644 struct dentry *dentry = ctx->cfile->dentry;
2645 unsigned int i;
2646 int rc;
2647
2648 tcon = tlink_tcon(ctx->cfile->tlink);
2649 cifs_sb = CIFS_SB(dentry->d_sb);
2650
2651 mutex_lock(&ctx->aio_mutex);
2652
2653 if (list_empty(&ctx->list)) {
2654 mutex_unlock(&ctx->aio_mutex);
2655 return;
2656 }
2657
2658 rc = ctx->rc;
2659 /*
2660 * Wait for and collect replies for any successful sends in order of
2661 * increasing offset. Once an error is hit, then return without waiting
2662 * for any more replies.
2663 */
2664 restart_loop:
2665 list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
2666 if (!rc) {
2667 if (!try_wait_for_completion(&wdata->done)) {
2668 mutex_unlock(&ctx->aio_mutex);
2669 return;
2670 }
2671
2672 if (wdata->result)
2673 rc = wdata->result;
2674 else
2675 ctx->total_len += wdata->bytes;
2676
2677 /* resend call if it's a retryable error */
2678 if (rc == -EAGAIN) {
2679 struct list_head tmp_list;
2680 struct iov_iter tmp_from = ctx->iter;
2681
2682 INIT_LIST_HEAD(&tmp_list);
2683 list_del_init(&wdata->list);
2684
2685 iov_iter_advance(&tmp_from,
2686 wdata->offset - ctx->pos);
2687
2688 rc = cifs_write_from_iter(wdata->offset,
2689 wdata->bytes, &tmp_from,
2690 ctx->cfile, cifs_sb, &tmp_list,
2691 ctx);
2692
2693 list_splice(&tmp_list, &ctx->list);
2694
2695 kref_put(&wdata->refcount,
2696 cifs_uncached_writedata_release);
2697 goto restart_loop;
2698 }
2699 }
2700 list_del_init(&wdata->list);
2701 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2702 }
2703
2704 for (i = 0; i < ctx->npages; i++)
2705 put_page(ctx->bv[i].bv_page);
2706
2707 cifs_stats_bytes_written(tcon, ctx->total_len);
2708 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);
2709
2710 ctx->rc = (rc == 0) ? ctx->total_len : rc;
2711
2712 mutex_unlock(&ctx->aio_mutex);
2713
2714 if (ctx->iocb && ctx->iocb->ki_complete)
2715 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
2716 else
2717 complete(&ctx->done);
2718 }
2719
2720 ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
2721 {
2722 struct file *file = iocb->ki_filp;
2723 ssize_t total_written = 0;
2724 struct cifsFileInfo *cfile;
2725 struct cifs_tcon *tcon;
2726 struct cifs_sb_info *cifs_sb;
2727 struct cifs_aio_ctx *ctx;
2728 struct iov_iter saved_from = *from;
2729 int rc;
2730
2731 /*
2732 * BB - optimize the way when signing is disabled. We can drop this
2733 * extra memory-to-memory copying and use iovec buffers for constructing
2734 * write request.
2735 */
2736
2737 rc = generic_write_checks(iocb, from);
2738 if (rc <= 0)
2739 return rc;
2740
2741 cifs_sb = CIFS_FILE_SB(file);
2742 cfile = file->private_data;
2743 tcon = tlink_tcon(cfile->tlink);
2744
2745 if (!tcon->ses->server->ops->async_writev)
2746 return -ENOSYS;
2747
2748 ctx = cifs_aio_ctx_alloc();
2749 if (!ctx)
2750 return -ENOMEM;
2751
2752 ctx->cfile = cifsFileInfo_get(cfile);
2753
2754 if (!is_sync_kiocb(iocb))
2755 ctx->iocb = iocb;
2756
2757 ctx->pos = iocb->ki_pos;
2758
2759 rc = setup_aio_ctx_iter(ctx, from, WRITE);
2760 if (rc) {
2761 kref_put(&ctx->refcount, cifs_aio_ctx_release);
2762 return rc;
2763 }
2764
2765 /* grab a lock here due to read response handlers can access ctx */
2766 mutex_lock(&ctx->aio_mutex);
2767
2768 rc = cifs_write_from_iter(iocb->ki_pos, ctx->len, &saved_from,
2769 cfile, cifs_sb, &ctx->list, ctx);
2770
2771 /*
2772 * If at least one write was successfully sent, then discard any rc
2773 * value from the later writes. If the other write succeeds, then
2774 * we'll end up returning whatever was written. If it fails, then
2775 * we'll get a new rc value from that.
2776 */
2777 if (!list_empty(&ctx->list))
2778 rc = 0;
2779
2780 mutex_unlock(&ctx->aio_mutex);
2781
2782 if (rc) {
2783 kref_put(&ctx->refcount, cifs_aio_ctx_release);
2784 return rc;
2785 }
2786
2787 if (!is_sync_kiocb(iocb)) {
2788 kref_put(&ctx->refcount, cifs_aio_ctx_release);
2789 return -EIOCBQUEUED;
2790 }
2791
2792 rc = wait_for_completion_killable(&ctx->done);
2793 if (rc) {
2794 mutex_lock(&ctx->aio_mutex);
2795 ctx->rc = rc = -EINTR;
2796 total_written = ctx->total_len;
2797 mutex_unlock(&ctx->aio_mutex);
2798 } else {
2799 rc = ctx->rc;
2800 total_written = ctx->total_len;
2801 }
2802
2803 kref_put(&ctx->refcount, cifs_aio_ctx_release);
2804
2805 if (unlikely(!total_written))
2806 return rc;
2807
2808 iocb->ki_pos += total_written;
2809 return total_written;
2810 }
2811
2812 static ssize_t
2813 cifs_writev(struct kiocb *iocb, struct iov_iter *from)
2814 {
2815 struct file *file = iocb->ki_filp;
2816 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2817 struct inode *inode = file->f_mapping->host;
2818 struct cifsInodeInfo *cinode = CIFS_I(inode);
2819 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2820 ssize_t rc;
2821
2822 inode_lock(inode);
2823 /*
2824 * We need to hold the sem to be sure nobody modifies lock list
2825 * with a brlock that prevents writing.
2826 */
2827 down_read(&cinode->lock_sem);
2828
2829 rc = generic_write_checks(iocb, from);
2830 if (rc <= 0)
2831 goto out;
2832
2833 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
2834 server->vals->exclusive_lock_type, NULL,
2835 CIFS_WRITE_OP))
2836 rc = __generic_file_write_iter(iocb, from);
2837 else
2838 rc = -EACCES;
2839 out:
2840 up_read(&cinode->lock_sem);
2841 inode_unlock(inode);
2842
2843 if (rc > 0)
2844 rc = generic_write_sync(iocb, rc);
2845 return rc;
2846 }
2847
2848 ssize_t
2849 cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
2850 {
2851 struct inode *inode = file_inode(iocb->ki_filp);
2852 struct cifsInodeInfo *cinode = CIFS_I(inode);
2853 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2854 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2855 iocb->ki_filp->private_data;
2856 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2857 ssize_t written;
2858
2859 written = cifs_get_writer(cinode);
2860 if (written)
2861 return written;
2862
2863 if (CIFS_CACHE_WRITE(cinode)) {
2864 if (cap_unix(tcon->ses) &&
2865 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2866 && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
2867 written = generic_file_write_iter(iocb, from);
2868 goto out;
2869 }
2870 written = cifs_writev(iocb, from);
2871 goto out;
2872 }
2873 /*
2874 * For non-oplocked files in strict cache mode we need to write the data
2875 * to the server exactly from the pos to pos+len-1 rather than flush all
2876 * affected pages because it may cause a error with mandatory locks on
2877 * these pages but not on the region from pos to ppos+len-1.
2878 */
2879 written = cifs_user_writev(iocb, from);
2880 if (written > 0 && CIFS_CACHE_READ(cinode)) {
2881 /*
2882 * Windows 7 server can delay breaking level2 oplock if a write
2883 * request comes - break it on the client to prevent reading
2884 * an old data.
2885 */
2886 cifs_zap_mapping(inode);
2887 cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
2888 inode);
2889 cinode->oplock = 0;
2890 }
2891 out:
2892 cifs_put_writer(cinode);
2893 return written;
2894 }
2895
2896 static struct cifs_readdata *
2897 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
2898 {
2899 struct cifs_readdata *rdata;
2900
2901 rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2902 GFP_KERNEL);
2903 if (rdata != NULL) {
2904 kref_init(&rdata->refcount);
2905 INIT_LIST_HEAD(&rdata->list);
2906 init_completion(&rdata->done);
2907 INIT_WORK(&rdata->work, complete);
2908 }
2909
2910 return rdata;
2911 }
2912
2913 void
2914 cifs_readdata_release(struct kref *refcount)
2915 {
2916 struct cifs_readdata *rdata = container_of(refcount,
2917 struct cifs_readdata, refcount);
2918
2919 if (rdata->cfile)
2920 cifsFileInfo_put(rdata->cfile);
2921
2922 kfree(rdata);
2923 }
2924
2925 static int
2926 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2927 {
2928 int rc = 0;
2929 struct page *page;
2930 unsigned int i;
2931
2932 for (i = 0; i < nr_pages; i++) {
2933 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2934 if (!page) {
2935 rc = -ENOMEM;
2936 break;
2937 }
2938 rdata->pages[i] = page;
2939 }
2940
2941 if (rc) {
2942 for (i = 0; i < nr_pages; i++) {
2943 put_page(rdata->pages[i]);
2944 rdata->pages[i] = NULL;
2945 }
2946 }
2947 return rc;
2948 }
2949
2950 static void
2951 cifs_uncached_readdata_release(struct kref *refcount)
2952 {
2953 struct cifs_readdata *rdata = container_of(refcount,
2954 struct cifs_readdata, refcount);
2955 unsigned int i;
2956
2957 kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
2958 for (i = 0; i < rdata->nr_pages; i++) {
2959 put_page(rdata->pages[i]);
2960 rdata->pages[i] = NULL;
2961 }
2962 cifs_readdata_release(refcount);
2963 }
2964
2965 /**
2966 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2967 * @rdata: the readdata response with list of pages holding data
2968 * @iter: destination for our data
2969 *
2970 * This function copies data from a list of pages in a readdata response into
2971 * an array of iovecs. It will first calculate where the data should go
2972 * based on the info in the readdata and then copy the data into that spot.
2973 */
2974 static int
2975 cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
2976 {
2977 size_t remaining = rdata->got_bytes;
2978 unsigned int i;
2979
2980 for (i = 0; i < rdata->nr_pages; i++) {
2981 struct page *page = rdata->pages[i];
2982 size_t copy = min_t(size_t, remaining, PAGE_SIZE);
2983 size_t written;
2984
2985 if (unlikely(iter->type & ITER_PIPE)) {
2986 void *addr = kmap_atomic(page);
2987
2988 written = copy_to_iter(addr, copy, iter);
2989 kunmap_atomic(addr);
2990 } else
2991 written = copy_page_to_iter(page, 0, copy, iter);
2992 remaining -= written;
2993 if (written < copy && iov_iter_count(iter) > 0)
2994 break;
2995 }
2996 return remaining ? -EFAULT : 0;
2997 }
2998
2999 static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);
3000
3001 static void
3002 cifs_uncached_readv_complete(struct work_struct *work)
3003 {
3004 struct cifs_readdata *rdata = container_of(work,
3005 struct cifs_readdata, work);
3006
3007 complete(&rdata->done);
3008 collect_uncached_read_data(rdata->ctx);
3009 /* the below call can possibly free the last ref to aio ctx */
3010 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3011 }
3012
3013 static int
3014 uncached_fill_pages(struct TCP_Server_Info *server,
3015 struct cifs_readdata *rdata, struct iov_iter *iter,
3016 unsigned int len)
3017 {
3018 int result = 0;
3019 unsigned int i;
3020 unsigned int nr_pages = rdata->nr_pages;
3021
3022 rdata->got_bytes = 0;
3023 rdata->tailsz = PAGE_SIZE;
3024 for (i = 0; i < nr_pages; i++) {
3025 struct page *page = rdata->pages[i];
3026 size_t n;
3027
3028 if (len <= 0) {
3029 /* no need to hold page hostage */
3030 rdata->pages[i] = NULL;
3031 rdata->nr_pages--;
3032 put_page(page);
3033 continue;
3034 }
3035 n = len;
3036 if (len >= PAGE_SIZE) {
3037 /* enough data to fill the page */
3038 n = PAGE_SIZE;
3039 len -= n;
3040 } else {
3041 zero_user(page, len, PAGE_SIZE - len);
3042 rdata->tailsz = len;
3043 len = 0;
3044 }
3045 if (iter)
3046 result = copy_page_from_iter(page, 0, n, iter);
3047 else
3048 result = cifs_read_page_from_socket(server, page, n);
3049 if (result < 0)
3050 break;
3051
3052 rdata->got_bytes += result;
3053 }
3054
3055 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3056 rdata->got_bytes : result;
3057 }
3058
3059 static int
3060 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
3061 struct cifs_readdata *rdata, unsigned int len)
3062 {
3063 return uncached_fill_pages(server, rdata, NULL, len);
3064 }
3065
3066 static int
3067 cifs_uncached_copy_into_pages(struct TCP_Server_Info *server,
3068 struct cifs_readdata *rdata,
3069 struct iov_iter *iter)
3070 {
3071 return uncached_fill_pages(server, rdata, iter, iter->count);
3072 }
3073
3074 static int
3075 cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3076 struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
3077 struct cifs_aio_ctx *ctx)
3078 {
3079 struct cifs_readdata *rdata;
3080 unsigned int npages, rsize, credits;
3081 size_t cur_len;
3082 int rc;
3083 pid_t pid;
3084 struct TCP_Server_Info *server;
3085
3086 server = tlink_tcon(open_file->tlink)->ses->server;
3087
3088 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3089 pid = open_file->pid;
3090 else
3091 pid = current->tgid;
3092
3093 do {
3094 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3095 &rsize, &credits);
3096 if (rc)
3097 break;
3098
3099 cur_len = min_t(const size_t, len, rsize);
3100 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
3101
3102 /* allocate a readdata struct */
3103 rdata = cifs_readdata_alloc(npages,
3104 cifs_uncached_readv_complete);
3105 if (!rdata) {
3106 add_credits_and_wake_if(server, credits, 0);
3107 rc = -ENOMEM;
3108 break;
3109 }
3110
3111 rc = cifs_read_allocate_pages(rdata, npages);
3112 if (rc)
3113 goto error;
3114
3115 rdata->cfile = cifsFileInfo_get(open_file);
3116 rdata->nr_pages = npages;
3117 rdata->offset = offset;
3118 rdata->bytes = cur_len;
3119 rdata->pid = pid;
3120 rdata->pagesz = PAGE_SIZE;
3121 rdata->read_into_pages = cifs_uncached_read_into_pages;
3122 rdata->copy_into_pages = cifs_uncached_copy_into_pages;
3123 rdata->credits = credits;
3124 rdata->ctx = ctx;
3125 kref_get(&ctx->refcount);
3126
3127 if (!rdata->cfile->invalidHandle ||
3128 !(rc = cifs_reopen_file(rdata->cfile, true)))
3129 rc = server->ops->async_readv(rdata);
3130 error:
3131 if (rc) {
3132 add_credits_and_wake_if(server, rdata->credits, 0);
3133 kref_put(&rdata->refcount,
3134 cifs_uncached_readdata_release);
3135 if (rc == -EAGAIN)
3136 continue;
3137 break;
3138 }
3139
3140 list_add_tail(&rdata->list, rdata_list);
3141 offset += cur_len;
3142 len -= cur_len;
3143 } while (len > 0);
3144
3145 return rc;
3146 }
3147
3148 static void
3149 collect_uncached_read_data(struct cifs_aio_ctx *ctx)
3150 {
3151 struct cifs_readdata *rdata, *tmp;
3152 struct iov_iter *to = &ctx->iter;
3153 struct cifs_sb_info *cifs_sb;
3154 struct cifs_tcon *tcon;
3155 unsigned int i;
3156 int rc;
3157
3158 tcon = tlink_tcon(ctx->cfile->tlink);
3159 cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
3160
3161 mutex_lock(&ctx->aio_mutex);
3162
3163 if (list_empty(&ctx->list)) {
3164 mutex_unlock(&ctx->aio_mutex);
3165 return;
3166 }
3167
3168 rc = ctx->rc;
3169 /* the loop below should proceed in the order of increasing offsets */
3170 again:
3171 list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
3172 if (!rc) {
3173 if (!try_wait_for_completion(&rdata->done)) {
3174 mutex_unlock(&ctx->aio_mutex);
3175 return;
3176 }
3177
3178 if (rdata->result == -EAGAIN) {
3179 /* resend call if it's a retryable error */
3180 struct list_head tmp_list;
3181 unsigned int got_bytes = rdata->got_bytes;
3182
3183 list_del_init(&rdata->list);
3184 INIT_LIST_HEAD(&tmp_list);
3185
3186 /*
3187 * Got a part of data and then reconnect has
3188 * happened -- fill the buffer and continue
3189 * reading.
3190 */
3191 if (got_bytes && got_bytes < rdata->bytes) {
3192 rc = cifs_readdata_to_iov(rdata, to);
3193 if (rc) {
3194 kref_put(&rdata->refcount,
3195 cifs_uncached_readdata_release);
3196 continue;
3197 }
3198 }
3199
3200 rc = cifs_send_async_read(
3201 rdata->offset + got_bytes,
3202 rdata->bytes - got_bytes,
3203 rdata->cfile, cifs_sb,
3204 &tmp_list, ctx);
3205
3206 list_splice(&tmp_list, &ctx->list);
3207
3208 kref_put(&rdata->refcount,
3209 cifs_uncached_readdata_release);
3210 goto again;
3211 } else if (rdata->result)
3212 rc = rdata->result;
3213 else
3214 rc = cifs_readdata_to_iov(rdata, to);
3215
3216 /* if there was a short read -- discard anything left */
3217 if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3218 rc = -ENODATA;
3219 }
3220 list_del_init(&rdata->list);
3221 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3222 }
3223
3224 for (i = 0; i < ctx->npages; i++) {
3225 if (ctx->should_dirty)
3226 set_page_dirty(ctx->bv[i].bv_page);
3227 put_page(ctx->bv[i].bv_page);
3228 }
3229
3230 ctx->total_len = ctx->len - iov_iter_count(to);
3231
3232 cifs_stats_bytes_read(tcon, ctx->total_len);
3233
3234 /* mask nodata case */
3235 if (rc == -ENODATA)
3236 rc = 0;
3237
3238 ctx->rc = (rc == 0) ? ctx->total_len : rc;
3239
3240 mutex_unlock(&ctx->aio_mutex);
3241
3242 if (ctx->iocb && ctx->iocb->ki_complete)
3243 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
3244 else
3245 complete(&ctx->done);
3246 }
3247
3248 ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
3249 {
3250 struct file *file = iocb->ki_filp;
3251 ssize_t rc;
3252 size_t len;
3253 ssize_t total_read = 0;
3254 loff_t offset = iocb->ki_pos;
3255 struct cifs_sb_info *cifs_sb;
3256 struct cifs_tcon *tcon;
3257 struct cifsFileInfo *cfile;
3258 struct cifs_aio_ctx *ctx;
3259
3260 len = iov_iter_count(to);
3261 if (!len)
3262 return 0;
3263
3264 cifs_sb = CIFS_FILE_SB(file);
3265 cfile = file->private_data;
3266 tcon = tlink_tcon(cfile->tlink);
3267
3268 if (!tcon->ses->server->ops->async_readv)
3269 return -ENOSYS;
3270
3271 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3272 cifs_dbg(FYI, "attempting read on write only file instance\n");
3273
3274 ctx = cifs_aio_ctx_alloc();
3275 if (!ctx)
3276 return -ENOMEM;
3277
3278 ctx->cfile = cifsFileInfo_get(cfile);
3279
3280 if (!is_sync_kiocb(iocb))
3281 ctx->iocb = iocb;
3282
3283 if (to->type == ITER_IOVEC)
3284 ctx->should_dirty = true;
3285
3286 rc = setup_aio_ctx_iter(ctx, to, READ);
3287 if (rc) {
3288 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3289 return rc;
3290 }
3291
3292 len = ctx->len;
3293
3294 /* grab a lock here due to read response handlers can access ctx */
3295 mutex_lock(&ctx->aio_mutex);
3296
3297 rc = cifs_send_async_read(offset, len, cfile, cifs_sb, &ctx->list, ctx);
3298
3299 /* if at least one read request send succeeded, then reset rc */
3300 if (!list_empty(&ctx->list))
3301 rc = 0;
3302
3303 mutex_unlock(&ctx->aio_mutex);
3304
3305 if (rc) {
3306 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3307 return rc;
3308 }
3309
3310 if (!is_sync_kiocb(iocb)) {
3311 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3312 return -EIOCBQUEUED;
3313 }
3314
3315 rc = wait_for_completion_killable(&ctx->done);
3316 if (rc) {
3317 mutex_lock(&ctx->aio_mutex);
3318 ctx->rc = rc = -EINTR;
3319 total_read = ctx->total_len;
3320 mutex_unlock(&ctx->aio_mutex);
3321 } else {
3322 rc = ctx->rc;
3323 total_read = ctx->total_len;
3324 }
3325
3326 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3327
3328 if (total_read) {
3329 iocb->ki_pos += total_read;
3330 return total_read;
3331 }
3332 return rc;
3333 }
3334
3335 ssize_t
3336 cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3337 {
3338 struct inode *inode = file_inode(iocb->ki_filp);
3339 struct cifsInodeInfo *cinode = CIFS_I(inode);
3340 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3341 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3342 iocb->ki_filp->private_data;
3343 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3344 int rc = -EACCES;
3345
3346 /*
3347 * In strict cache mode we need to read from the server all the time
3348 * if we don't have level II oplock because the server can delay mtime
3349 * change - so we can't make a decision about inode invalidating.
3350 * And we can also fail with pagereading if there are mandatory locks
3351 * on pages affected by this read but not on the region from pos to
3352 * pos+len-1.
3353 */
3354 if (!CIFS_CACHE_READ(cinode))
3355 return cifs_user_readv(iocb, to);
3356
3357 if (cap_unix(tcon->ses) &&
3358 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3359 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
3360 return generic_file_read_iter(iocb, to);
3361
3362 /*
3363 * We need to hold the sem to be sure nobody modifies lock list
3364 * with a brlock that prevents reading.
3365 */
3366 down_read(&cinode->lock_sem);
3367 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3368 tcon->ses->server->vals->shared_lock_type,
3369 NULL, CIFS_READ_OP))
3370 rc = generic_file_read_iter(iocb, to);
3371 up_read(&cinode->lock_sem);
3372 return rc;
3373 }
3374
3375 static ssize_t
3376 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
3377 {
3378 int rc = -EACCES;
3379 unsigned int bytes_read = 0;
3380 unsigned int total_read;
3381 unsigned int current_read_size;
3382 unsigned int rsize;
3383 struct cifs_sb_info *cifs_sb;
3384 struct cifs_tcon *tcon;
3385 struct TCP_Server_Info *server;
3386 unsigned int xid;
3387 char *cur_offset;
3388 struct cifsFileInfo *open_file;
3389 struct cifs_io_parms io_parms;
3390 int buf_type = CIFS_NO_BUFFER;
3391 __u32 pid;
3392
3393 xid = get_xid();
3394 cifs_sb = CIFS_FILE_SB(file);
3395
3396 /* FIXME: set up handlers for larger reads and/or convert to async */
3397 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3398
3399 if (file->private_data == NULL) {
3400 rc = -EBADF;
3401 free_xid(xid);
3402 return rc;
3403 }
3404 open_file = file->private_data;
3405 tcon = tlink_tcon(open_file->tlink);
3406 server = tcon->ses->server;
3407
3408 if (!server->ops->sync_read) {
3409 free_xid(xid);
3410 return -ENOSYS;
3411 }
3412
3413 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3414 pid = open_file->pid;
3415 else
3416 pid = current->tgid;
3417
3418 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3419 cifs_dbg(FYI, "attempting read on write only file instance\n");
3420
3421 for (total_read = 0, cur_offset = read_data; read_size > total_read;
3422 total_read += bytes_read, cur_offset += bytes_read) {
3423 do {
3424 current_read_size = min_t(uint, read_size - total_read,
3425 rsize);
3426 /*
3427 * For windows me and 9x we do not want to request more
3428 * than it negotiated since it will refuse the read
3429 * then.
3430 */
3431 if ((tcon->ses) && !(tcon->ses->capabilities &
3432 tcon->ses->server->vals->cap_large_files)) {
3433 current_read_size = min_t(uint,
3434 current_read_size, CIFSMaxBufSize);
3435 }
3436 if (open_file->invalidHandle) {
3437 rc = cifs_reopen_file(open_file, true);
3438 if (rc != 0)
3439 break;
3440 }
3441 io_parms.pid = pid;
3442 io_parms.tcon = tcon;
3443 io_parms.offset = *offset;
3444 io_parms.length = current_read_size;
3445 rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3446 &bytes_read, &cur_offset,
3447 &buf_type);
3448 } while (rc == -EAGAIN);
3449
3450 if (rc || (bytes_read == 0)) {
3451 if (total_read) {
3452 break;
3453 } else {
3454 free_xid(xid);
3455 return rc;
3456 }
3457 } else {
3458 cifs_stats_bytes_read(tcon, total_read);
3459 *offset += bytes_read;
3460 }
3461 }
3462 free_xid(xid);
3463 return total_read;
3464 }
3465
3466 /*
3467 * If the page is mmap'ed into a process' page tables, then we need to make
3468 * sure that it doesn't change while being written back.
3469 */
3470 static int
3471 cifs_page_mkwrite(struct vm_fault *vmf)
3472 {
3473 struct page *page = vmf->page;
3474
3475 lock_page(page);
3476 return VM_FAULT_LOCKED;
3477 }
3478
3479 static const struct vm_operations_struct cifs_file_vm_ops = {
3480 .fault = filemap_fault,
3481 .map_pages = filemap_map_pages,
3482 .page_mkwrite = cifs_page_mkwrite,
3483 };
3484
3485 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3486 {
3487 int rc, xid;
3488 struct inode *inode = file_inode(file);
3489
3490 xid = get_xid();
3491
3492 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
3493 rc = cifs_zap_mapping(inode);
3494 if (rc)
3495 return rc;
3496 }
3497
3498 rc = generic_file_mmap(file, vma);
3499 if (rc == 0)
3500 vma->vm_ops = &cifs_file_vm_ops;
3501 free_xid(xid);
3502 return rc;
3503 }
3504
3505 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3506 {
3507 int rc, xid;
3508
3509 xid = get_xid();
3510 rc = cifs_revalidate_file(file);
3511 if (rc) {
3512 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3513 rc);
3514 free_xid(xid);
3515 return rc;
3516 }
3517 rc = generic_file_mmap(file, vma);
3518 if (rc == 0)
3519 vma->vm_ops = &cifs_file_vm_ops;
3520 free_xid(xid);
3521 return rc;
3522 }
3523
3524 static void
3525 cifs_readv_complete(struct work_struct *work)
3526 {
3527 unsigned int i, got_bytes;
3528 struct cifs_readdata *rdata = container_of(work,
3529 struct cifs_readdata, work);
3530
3531 got_bytes = rdata->got_bytes;
3532 for (i = 0; i < rdata->nr_pages; i++) {
3533 struct page *page = rdata->pages[i];
3534
3535 lru_cache_add_file(page);
3536
3537 if (rdata->result == 0 ||
3538 (rdata->result == -EAGAIN && got_bytes)) {
3539 flush_dcache_page(page);
3540 SetPageUptodate(page);
3541 }
3542
3543 unlock_page(page);
3544
3545 if (rdata->result == 0 ||
3546 (rdata->result == -EAGAIN && got_bytes))
3547 cifs_readpage_to_fscache(rdata->mapping->host, page);
3548
3549 got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
3550
3551 put_page(page);
3552 rdata->pages[i] = NULL;
3553 }
3554 kref_put(&rdata->refcount, cifs_readdata_release);
3555 }
3556
3557 static int
3558 readpages_fill_pages(struct TCP_Server_Info *server,
3559 struct cifs_readdata *rdata, struct iov_iter *iter,
3560 unsigned int len)
3561 {
3562 int result = 0;
3563 unsigned int i;
3564 u64 eof;
3565 pgoff_t eof_index;
3566 unsigned int nr_pages = rdata->nr_pages;
3567
3568 /* determine the eof that the server (probably) has */
3569 eof = CIFS_I(rdata->mapping->host)->server_eof;
3570 eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
3571 cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
3572
3573 rdata->got_bytes = 0;
3574 rdata->tailsz = PAGE_SIZE;
3575 for (i = 0; i < nr_pages; i++) {
3576 struct page *page = rdata->pages[i];
3577 size_t n = PAGE_SIZE;
3578
3579 if (len >= PAGE_SIZE) {
3580 len -= PAGE_SIZE;
3581 } else if (len > 0) {
3582 /* enough for partial page, fill and zero the rest */
3583 zero_user(page, len, PAGE_SIZE - len);
3584 n = rdata->tailsz = len;
3585 len = 0;
3586 } else if (page->index > eof_index) {
3587 /*
3588 * The VFS will not try to do readahead past the
3589 * i_size, but it's possible that we have outstanding
3590 * writes with gaps in the middle and the i_size hasn't
3591 * caught up yet. Populate those with zeroed out pages
3592 * to prevent the VFS from repeatedly attempting to
3593 * fill them until the writes are flushed.
3594 */
3595 zero_user(page, 0, PAGE_SIZE);
3596 lru_cache_add_file(page);
3597 flush_dcache_page(page);
3598 SetPageUptodate(page);
3599 unlock_page(page);
3600 put_page(page);
3601 rdata->pages[i] = NULL;
3602 rdata->nr_pages--;
3603 continue;
3604 } else {
3605 /* no need to hold page hostage */
3606 lru_cache_add_file(page);
3607 unlock_page(page);
3608 put_page(page);
3609 rdata->pages[i] = NULL;
3610 rdata->nr_pages--;
3611 continue;
3612 }
3613
3614 if (iter)
3615 result = copy_page_from_iter(page, 0, n, iter);
3616 else
3617 result = cifs_read_page_from_socket(server, page, n);
3618 if (result < 0)
3619 break;
3620
3621 rdata->got_bytes += result;
3622 }
3623
3624 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3625 rdata->got_bytes : result;
3626 }
3627
3628 static int
3629 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3630 struct cifs_readdata *rdata, unsigned int len)
3631 {
3632 return readpages_fill_pages(server, rdata, NULL, len);
3633 }
3634
3635 static int
3636 cifs_readpages_copy_into_pages(struct TCP_Server_Info *server,
3637 struct cifs_readdata *rdata,
3638 struct iov_iter *iter)
3639 {
3640 return readpages_fill_pages(server, rdata, iter, iter->count);
3641 }
3642
3643 static int
3644 readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
3645 unsigned int rsize, struct list_head *tmplist,
3646 unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
3647 {
3648 struct page *page, *tpage;
3649 unsigned int expected_index;
3650 int rc;
3651 gfp_t gfp = readahead_gfp_mask(mapping);
3652
3653 INIT_LIST_HEAD(tmplist);
3654
3655 page = list_entry(page_list->prev, struct page, lru);
3656
3657 /*
3658 * Lock the page and put it in the cache. Since no one else
3659 * should have access to this page, we're safe to simply set
3660 * PG_locked without checking it first.
3661 */
3662 __SetPageLocked(page);
3663 rc = add_to_page_cache_locked(page, mapping,
3664 page->index, gfp);
3665
3666 /* give up if we can't stick it in the cache */
3667 if (rc) {
3668 __ClearPageLocked(page);
3669 return rc;
3670 }
3671
3672 /* move first page to the tmplist */
3673 *offset = (loff_t)page->index << PAGE_SHIFT;
3674 *bytes = PAGE_SIZE;
3675 *nr_pages = 1;
3676 list_move_tail(&page->lru, tmplist);
3677
3678 /* now try and add more pages onto the request */
3679 expected_index = page->index + 1;
3680 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3681 /* discontinuity ? */
3682 if (page->index != expected_index)
3683 break;
3684
3685 /* would this page push the read over the rsize? */
3686 if (*bytes + PAGE_SIZE > rsize)
3687 break;
3688
3689 __SetPageLocked(page);
3690 if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
3691 __ClearPageLocked(page);
3692 break;
3693 }
3694 list_move_tail(&page->lru, tmplist);
3695 (*bytes) += PAGE_SIZE;
3696 expected_index++;
3697 (*nr_pages)++;
3698 }
3699 return rc;
3700 }
3701
3702 static int cifs_readpages(struct file *file, struct address_space *mapping,
3703 struct list_head *page_list, unsigned num_pages)
3704 {
3705 int rc;
3706 struct list_head tmplist;
3707 struct cifsFileInfo *open_file = file->private_data;
3708 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
3709 struct TCP_Server_Info *server;
3710 pid_t pid;
3711
3712 /*
3713 * Reads as many pages as possible from fscache. Returns -ENOBUFS
3714 * immediately if the cookie is negative
3715 *
3716 * After this point, every page in the list might have PG_fscache set,
3717 * so we will need to clean that up off of every page we don't use.
3718 */
3719 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3720 &num_pages);
3721 if (rc == 0)
3722 return rc;
3723
3724 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3725 pid = open_file->pid;
3726 else
3727 pid = current->tgid;
3728
3729 rc = 0;
3730 server = tlink_tcon(open_file->tlink)->ses->server;
3731
3732 cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
3733 __func__, file, mapping, num_pages);
3734
3735 /*
3736 * Start with the page at end of list and move it to private
3737 * list. Do the same with any following pages until we hit
3738 * the rsize limit, hit an index discontinuity, or run out of
3739 * pages. Issue the async read and then start the loop again
3740 * until the list is empty.
3741 *
3742 * Note that list order is important. The page_list is in
3743 * the order of declining indexes. When we put the pages in
3744 * the rdata->pages, then we want them in increasing order.
3745 */
3746 while (!list_empty(page_list)) {
3747 unsigned int i, nr_pages, bytes, rsize;
3748 loff_t offset;
3749 struct page *page, *tpage;
3750 struct cifs_readdata *rdata;
3751 unsigned credits;
3752
3753 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3754 &rsize, &credits);
3755 if (rc)
3756 break;
3757
3758 /*
3759 * Give up immediately if rsize is too small to read an entire
3760 * page. The VFS will fall back to readpage. We should never
3761 * reach this point however since we set ra_pages to 0 when the
3762 * rsize is smaller than a cache page.
3763 */
3764 if (unlikely(rsize < PAGE_SIZE)) {
3765 add_credits_and_wake_if(server, credits, 0);
3766 return 0;
3767 }
3768
3769 rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
3770 &nr_pages, &offset, &bytes);
3771 if (rc) {
3772 add_credits_and_wake_if(server, credits, 0);
3773 break;
3774 }
3775
3776 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3777 if (!rdata) {
3778 /* best to give up if we're out of mem */
3779 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3780 list_del(&page->lru);
3781 lru_cache_add_file(page);
3782 unlock_page(page);
3783 put_page(page);
3784 }
3785 rc = -ENOMEM;
3786 add_credits_and_wake_if(server, credits, 0);
3787 break;
3788 }
3789
3790 rdata->cfile = cifsFileInfo_get(open_file);
3791 rdata->mapping = mapping;
3792 rdata->offset = offset;
3793 rdata->bytes = bytes;
3794 rdata->pid = pid;
3795 rdata->pagesz = PAGE_SIZE;
3796 rdata->read_into_pages = cifs_readpages_read_into_pages;
3797 rdata->copy_into_pages = cifs_readpages_copy_into_pages;
3798 rdata->credits = credits;
3799
3800 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3801 list_del(&page->lru);
3802 rdata->pages[rdata->nr_pages++] = page;
3803 }
3804
3805 if (!rdata->cfile->invalidHandle ||
3806 !(rc = cifs_reopen_file(rdata->cfile, true)))
3807 rc = server->ops->async_readv(rdata);
3808 if (rc) {
3809 add_credits_and_wake_if(server, rdata->credits, 0);
3810 for (i = 0; i < rdata->nr_pages; i++) {
3811 page = rdata->pages[i];
3812 lru_cache_add_file(page);
3813 unlock_page(page);
3814 put_page(page);
3815 }
3816 /* Fallback to the readpage in error/reconnect cases */
3817 kref_put(&rdata->refcount, cifs_readdata_release);
3818 break;
3819 }
3820
3821 kref_put(&rdata->refcount, cifs_readdata_release);
3822 }
3823
3824 /* Any pages that have been shown to fscache but didn't get added to
3825 * the pagecache must be uncached before they get returned to the
3826 * allocator.
3827 */
3828 cifs_fscache_readpages_cancel(mapping->host, page_list);
3829 return rc;
3830 }
3831
3832 /*
3833 * cifs_readpage_worker must be called with the page pinned
3834 */
3835 static int cifs_readpage_worker(struct file *file, struct page *page,
3836 loff_t *poffset)
3837 {
3838 char *read_data;
3839 int rc;
3840
3841 /* Is the page cached? */
3842 rc = cifs_readpage_from_fscache(file_inode(file), page);
3843 if (rc == 0)
3844 goto read_complete;
3845
3846 read_data = kmap(page);
3847 /* for reads over a certain size could initiate async read ahead */
3848
3849 rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
3850
3851 if (rc < 0)
3852 goto io_error;
3853 else
3854 cifs_dbg(FYI, "Bytes read %d\n", rc);
3855
3856 file_inode(file)->i_atime =
3857 current_time(file_inode(file));
3858
3859 if (PAGE_SIZE > rc)
3860 memset(read_data + rc, 0, PAGE_SIZE - rc);
3861
3862 flush_dcache_page(page);
3863 SetPageUptodate(page);
3864
3865 /* send this page to the cache */
3866 cifs_readpage_to_fscache(file_inode(file), page);
3867
3868 rc = 0;
3869
3870 io_error:
3871 kunmap(page);
3872 unlock_page(page);
3873
3874 read_complete:
3875 return rc;
3876 }
3877
3878 static int cifs_readpage(struct file *file, struct page *page)
3879 {
3880 loff_t offset = (loff_t)page->index << PAGE_SHIFT;
3881 int rc = -EACCES;
3882 unsigned int xid;
3883
3884 xid = get_xid();
3885
3886 if (file->private_data == NULL) {
3887 rc = -EBADF;
3888 free_xid(xid);
3889 return rc;
3890 }
3891
3892 cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
3893 page, (int)offset, (int)offset);
3894
3895 rc = cifs_readpage_worker(file, page, &offset);
3896
3897 free_xid(xid);
3898 return rc;
3899 }
3900
3901 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3902 {
3903 struct cifsFileInfo *open_file;
3904 struct cifs_tcon *tcon =
3905 cifs_sb_master_tcon(CIFS_SB(cifs_inode->vfs_inode.i_sb));
3906
3907 spin_lock(&tcon->open_file_lock);
3908 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3909 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3910 spin_unlock(&tcon->open_file_lock);
3911 return 1;
3912 }
3913 }
3914 spin_unlock(&tcon->open_file_lock);
3915 return 0;
3916 }
3917
3918 /* We do not want to update the file size from server for inodes
3919 open for write - to avoid races with writepage extending
3920 the file - in the future we could consider allowing
3921 refreshing the inode only on increases in the file size
3922 but this is tricky to do without racing with writebehind
3923 page caching in the current Linux kernel design */
3924 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
3925 {
3926 if (!cifsInode)
3927 return true;
3928
3929 if (is_inode_writable(cifsInode)) {
3930 /* This inode is open for write at least once */
3931 struct cifs_sb_info *cifs_sb;
3932
3933 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
3934 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
3935 /* since no page cache to corrupt on directio
3936 we can change size safely */
3937 return true;
3938 }
3939
3940 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3941 return true;
3942
3943 return false;
3944 } else
3945 return true;
3946 }
3947
3948 static int cifs_write_begin(struct file *file, struct address_space *mapping,
3949 loff_t pos, unsigned len, unsigned flags,
3950 struct page **pagep, void **fsdata)
3951 {
3952 int oncethru = 0;
3953 pgoff_t index = pos >> PAGE_SHIFT;
3954 loff_t offset = pos & (PAGE_SIZE - 1);
3955 loff_t page_start = pos & PAGE_MASK;
3956 loff_t i_size;
3957 struct page *page;
3958 int rc = 0;
3959
3960 cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
3961
3962 start:
3963 page = grab_cache_page_write_begin(mapping, index, flags);
3964 if (!page) {
3965 rc = -ENOMEM;
3966 goto out;
3967 }
3968
3969 if (PageUptodate(page))
3970 goto out;
3971
3972 /*
3973 * If we write a full page it will be up to date, no need to read from
3974 * the server. If the write is short, we'll end up doing a sync write
3975 * instead.
3976 */
3977 if (len == PAGE_SIZE)
3978 goto out;
3979
3980 /*
3981 * optimize away the read when we have an oplock, and we're not
3982 * expecting to use any of the data we'd be reading in. That
3983 * is, when the page lies beyond the EOF, or straddles the EOF
3984 * and the write will cover all of the existing data.
3985 */
3986 if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
3987 i_size = i_size_read(mapping->host);
3988 if (page_start >= i_size ||
3989 (offset == 0 && (pos + len) >= i_size)) {
3990 zero_user_segments(page, 0, offset,
3991 offset + len,
3992 PAGE_SIZE);
3993 /*
3994 * PageChecked means that the parts of the page
3995 * to which we're not writing are considered up
3996 * to date. Once the data is copied to the
3997 * page, it can be set uptodate.
3998 */
3999 SetPageChecked(page);
4000 goto out;
4001 }
4002 }
4003
4004 if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
4005 /*
4006 * might as well read a page, it is fast enough. If we get
4007 * an error, we don't need to return it. cifs_write_end will
4008 * do a sync write instead since PG_uptodate isn't set.
4009 */
4010 cifs_readpage_worker(file, page, &page_start);
4011 put_page(page);
4012 oncethru = 1;
4013 goto start;
4014 } else {
4015 /* we could try using another file handle if there is one -
4016 but how would we lock it to prevent close of that handle
4017 racing with this read? In any case
4018 this will be written out by write_end so is fine */
4019 }
4020 out:
4021 *pagep = page;
4022 return rc;
4023 }
4024
4025 static int cifs_release_page(struct page *page, gfp_t gfp)
4026 {
4027 if (PagePrivate(page))
4028 return 0;
4029
4030 return cifs_fscache_release_page(page, gfp);
4031 }
4032
4033 static void cifs_invalidate_page(struct page *page, unsigned int offset,
4034 unsigned int length)
4035 {
4036 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
4037
4038 if (offset == 0 && length == PAGE_SIZE)
4039 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
4040 }
4041
4042 static int cifs_launder_page(struct page *page)
4043 {
4044 int rc = 0;
4045 loff_t range_start = page_offset(page);
4046 loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
4047 struct writeback_control wbc = {
4048 .sync_mode = WB_SYNC_ALL,
4049 .nr_to_write = 0,
4050 .range_start = range_start,
4051 .range_end = range_end,
4052 };
4053
4054 cifs_dbg(FYI, "Launder page: %p\n", page);
4055
4056 if (clear_page_dirty_for_io(page))
4057 rc = cifs_writepage_locked(page, &wbc);
4058
4059 cifs_fscache_invalidate_page(page, page->mapping->host);
4060 return rc;
4061 }
4062
4063 void cifs_oplock_break(struct work_struct *work)
4064 {
4065 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
4066 oplock_break);
4067 struct inode *inode = d_inode(cfile->dentry);
4068 struct cifsInodeInfo *cinode = CIFS_I(inode);
4069 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4070 struct TCP_Server_Info *server = tcon->ses->server;
4071 int rc = 0;
4072
4073 wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
4074 TASK_UNINTERRUPTIBLE);
4075
4076 server->ops->downgrade_oplock(server, cinode,
4077 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, &cinode->flags));
4078
4079 if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
4080 cifs_has_mand_locks(cinode)) {
4081 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
4082 inode);
4083 cinode->oplock = 0;
4084 }
4085
4086 if (inode && S_ISREG(inode->i_mode)) {
4087 if (CIFS_CACHE_READ(cinode))
4088 break_lease(inode, O_RDONLY);
4089 else
4090 break_lease(inode, O_WRONLY);
4091 rc = filemap_fdatawrite(inode->i_mapping);
4092 if (!CIFS_CACHE_READ(cinode)) {
4093 rc = filemap_fdatawait(inode->i_mapping);
4094 mapping_set_error(inode->i_mapping, rc);
4095 cifs_zap_mapping(inode);
4096 }
4097 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
4098 }
4099
4100 rc = cifs_push_locks(cfile);
4101 if (rc)
4102 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
4103
4104 /*
4105 * releasing stale oplock after recent reconnect of smb session using
4106 * a now incorrect file handle is not a data integrity issue but do
4107 * not bother sending an oplock release if session to server still is
4108 * disconnected since oplock already released by the server
4109 */
4110 if (!cfile->oplock_break_cancelled) {
4111 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
4112 cinode);
4113 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
4114 }
4115 cifs_done_oplock_break(cinode);
4116 }
4117
4118 /*
4119 * The presence of cifs_direct_io() in the address space ops vector
4120 * allowes open() O_DIRECT flags which would have failed otherwise.
4121 *
4122 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
4123 * so this method should never be called.
4124 *
4125 * Direct IO is not yet supported in the cached mode.
4126 */
4127 static ssize_t
4128 cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
4129 {
4130 /*
4131 * FIXME
4132 * Eventually need to support direct IO for non forcedirectio mounts
4133 */
4134 return -EINVAL;
4135 }
4136
4137
4138 const struct address_space_operations cifs_addr_ops = {
4139 .readpage = cifs_readpage,
4140 .readpages = cifs_readpages,
4141 .writepage = cifs_writepage,
4142 .writepages = cifs_writepages,
4143 .write_begin = cifs_write_begin,
4144 .write_end = cifs_write_end,
4145 .set_page_dirty = __set_page_dirty_nobuffers,
4146 .releasepage = cifs_release_page,
4147 .direct_IO = cifs_direct_io,
4148 .invalidatepage = cifs_invalidate_page,
4149 .launder_page = cifs_launder_page,
4150 };
4151
4152 /*
4153 * cifs_readpages requires the server to support a buffer large enough to
4154 * contain the header plus one complete page of data. Otherwise, we need
4155 * to leave cifs_readpages out of the address space operations.
4156 */
4157 const struct address_space_operations cifs_addr_ops_smallbuf = {
4158 .readpage = cifs_readpage,
4159 .writepage = cifs_writepage,
4160 .writepages = cifs_writepages,
4161 .write_begin = cifs_write_begin,
4162 .write_end = cifs_write_end,
4163 .set_page_dirty = __set_page_dirty_nobuffers,
4164 .releasepage = cifs_release_page,
4165 .invalidatepage = cifs_invalidate_page,
4166 .launder_page = cifs_launder_page,
4167 };
4168
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.