1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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 <linux/mm.h>
37#include <asm/div64.h>
38#include "cifsfs.h"
39#include "cifspdu.h"
40#include "cifsglob.h"
41#include "cifsproto.h"
42#include "cifs_unicode.h"
43#include "cifs_debug.h"
44#include "cifs_fs_sb.h"
45#include "fscache.h"
46#include "smbdirect.h"
47
48static inline int cifs_convert_flags(unsigned int flags)
49{
50 if ((flags & O_ACCMODE) == O_RDONLY)
51 return GENERIC_READ;
52 else if ((flags & O_ACCMODE) == O_WRONLY)
53 return GENERIC_WRITE;
54 else if ((flags & O_ACCMODE) == O_RDWR) {
55
56
57
58 return (GENERIC_READ | GENERIC_WRITE);
59 }
60
61 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
62 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
63 FILE_READ_DATA);
64}
65
66static u32 cifs_posix_convert_flags(unsigned int flags)
67{
68 u32 posix_flags = 0;
69
70 if ((flags & O_ACCMODE) == O_RDONLY)
71 posix_flags = SMB_O_RDONLY;
72 else if ((flags & O_ACCMODE) == O_WRONLY)
73 posix_flags = SMB_O_WRONLY;
74 else if ((flags & O_ACCMODE) == O_RDWR)
75 posix_flags = SMB_O_RDWR;
76
77 if (flags & O_CREAT) {
78 posix_flags |= SMB_O_CREAT;
79 if (flags & O_EXCL)
80 posix_flags |= SMB_O_EXCL;
81 } else if (flags & O_EXCL)
82 cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
83 current->comm, current->tgid);
84
85 if (flags & O_TRUNC)
86 posix_flags |= SMB_O_TRUNC;
87
88 if (flags & O_DSYNC)
89 posix_flags |= SMB_O_SYNC;
90 if (flags & O_DIRECTORY)
91 posix_flags |= SMB_O_DIRECTORY;
92 if (flags & O_NOFOLLOW)
93 posix_flags |= SMB_O_NOFOLLOW;
94 if (flags & O_DIRECT)
95 posix_flags |= SMB_O_DIRECT;
96
97 return posix_flags;
98}
99
100static inline int cifs_get_disposition(unsigned int flags)
101{
102 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
103 return FILE_CREATE;
104 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
105 return FILE_OVERWRITE_IF;
106 else if ((flags & O_CREAT) == O_CREAT)
107 return FILE_OPEN_IF;
108 else if ((flags & O_TRUNC) == O_TRUNC)
109 return FILE_OVERWRITE;
110 else
111 return FILE_OPEN;
112}
113
114int cifs_posix_open(char *full_path, struct inode **pinode,
115 struct super_block *sb, int mode, unsigned int f_flags,
116 __u32 *poplock, __u16 *pnetfid, unsigned int xid)
117{
118 int rc;
119 FILE_UNIX_BASIC_INFO *presp_data;
120 __u32 posix_flags = 0;
121 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
122 struct cifs_fattr fattr;
123 struct tcon_link *tlink;
124 struct cifs_tcon *tcon;
125
126 cifs_dbg(FYI, "posix open %s\n", full_path);
127
128 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
129 if (presp_data == NULL)
130 return -ENOMEM;
131
132 tlink = cifs_sb_tlink(cifs_sb);
133 if (IS_ERR(tlink)) {
134 rc = PTR_ERR(tlink);
135 goto posix_open_ret;
136 }
137
138 tcon = tlink_tcon(tlink);
139 mode &= ~current_umask();
140
141 posix_flags = cifs_posix_convert_flags(f_flags);
142 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
143 poplock, full_path, cifs_sb->local_nls,
144 cifs_remap(cifs_sb));
145 cifs_put_tlink(tlink);
146
147 if (rc)
148 goto posix_open_ret;
149
150 if (presp_data->Type == cpu_to_le32(-1))
151 goto posix_open_ret;
152
153 if (!pinode)
154 goto posix_open_ret;
155
156 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
157
158
159 if (*pinode == NULL) {
160 cifs_fill_uniqueid(sb, &fattr);
161 *pinode = cifs_iget(sb, &fattr);
162 if (!*pinode) {
163 rc = -ENOMEM;
164 goto posix_open_ret;
165 }
166 } else {
167 cifs_fattr_to_inode(*pinode, &fattr);
168 }
169
170posix_open_ret:
171 kfree(presp_data);
172 return rc;
173}
174
175static int
176cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
177 struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
178 struct cifs_fid *fid, unsigned int xid)
179{
180 int rc;
181 int desired_access;
182 int disposition;
183 int create_options = CREATE_NOT_DIR;
184 FILE_ALL_INFO *buf;
185 struct TCP_Server_Info *server = tcon->ses->server;
186 struct cifs_open_parms oparms;
187
188 if (!server->ops->open)
189 return -ENOSYS;
190
191 desired_access = cifs_convert_flags(f_flags);
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217 disposition = cifs_get_disposition(f_flags);
218
219
220
221 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
222 if (!buf)
223 return -ENOMEM;
224
225 if (backup_cred(cifs_sb))
226 create_options |= CREATE_OPEN_BACKUP_INTENT;
227
228
229 if (f_flags & O_SYNC)
230 create_options |= CREATE_WRITE_THROUGH;
231
232 if (f_flags & O_DIRECT)
233 create_options |= CREATE_NO_BUFFER;
234
235 oparms.tcon = tcon;
236 oparms.cifs_sb = cifs_sb;
237 oparms.desired_access = desired_access;
238 oparms.create_options = create_options;
239 oparms.disposition = disposition;
240 oparms.path = full_path;
241 oparms.fid = fid;
242 oparms.reconnect = false;
243
244 rc = server->ops->open(xid, &oparms, oplock, buf);
245
246 if (rc)
247 goto out;
248
249 if (tcon->unix_ext)
250 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
251 xid);
252 else
253 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
254 xid, fid);
255
256out:
257 kfree(buf);
258 return rc;
259}
260
261static bool
262cifs_has_mand_locks(struct cifsInodeInfo *cinode)
263{
264 struct cifs_fid_locks *cur;
265 bool has_locks = false;
266
267 down_read(&cinode->lock_sem);
268 list_for_each_entry(cur, &cinode->llist, llist) {
269 if (!list_empty(&cur->locks)) {
270 has_locks = true;
271 break;
272 }
273 }
274 up_read(&cinode->lock_sem);
275 return has_locks;
276}
277
278struct cifsFileInfo *
279cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
280 struct tcon_link *tlink, __u32 oplock)
281{
282 struct dentry *dentry = file_dentry(file);
283 struct inode *inode = d_inode(dentry);
284 struct cifsInodeInfo *cinode = CIFS_I(inode);
285 struct cifsFileInfo *cfile;
286 struct cifs_fid_locks *fdlocks;
287 struct cifs_tcon *tcon = tlink_tcon(tlink);
288 struct TCP_Server_Info *server = tcon->ses->server;
289
290 cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
291 if (cfile == NULL)
292 return cfile;
293
294 fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
295 if (!fdlocks) {
296 kfree(cfile);
297 return NULL;
298 }
299
300 INIT_LIST_HEAD(&fdlocks->locks);
301 fdlocks->cfile = cfile;
302 cfile->llist = fdlocks;
303 down_write(&cinode->lock_sem);
304 list_add(&fdlocks->llist, &cinode->llist);
305 up_write(&cinode->lock_sem);
306
307 cfile->count = 1;
308 cfile->pid = current->tgid;
309 cfile->uid = current_fsuid();
310 cfile->dentry = dget(dentry);
311 cfile->f_flags = file->f_flags;
312 cfile->invalidHandle = false;
313 cfile->tlink = cifs_get_tlink(tlink);
314 INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
315 mutex_init(&cfile->fh_mutex);
316 spin_lock_init(&cfile->file_info_lock);
317
318 cifs_sb_active(inode->i_sb);
319
320
321
322
323
324 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
325 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
326 oplock = 0;
327 }
328
329 spin_lock(&tcon->open_file_lock);
330 if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
331 oplock = fid->pending_open->oplock;
332 list_del(&fid->pending_open->olist);
333
334 fid->purge_cache = false;
335 server->ops->set_fid(cfile, fid, oplock);
336
337 list_add(&cfile->tlist, &tcon->openFileList);
338 atomic_inc(&tcon->num_local_opens);
339
340
341 spin_lock(&cinode->open_file_lock);
342 if (file->f_mode & FMODE_READ)
343 list_add(&cfile->flist, &cinode->openFileList);
344 else
345 list_add_tail(&cfile->flist, &cinode->openFileList);
346 spin_unlock(&cinode->open_file_lock);
347 spin_unlock(&tcon->open_file_lock);
348
349 if (fid->purge_cache)
350 cifs_zap_mapping(inode);
351
352 file->private_data = cfile;
353 return cfile;
354}
355
356struct cifsFileInfo *
357cifsFileInfo_get(struct cifsFileInfo *cifs_file)
358{
359 spin_lock(&cifs_file->file_info_lock);
360 cifsFileInfo_get_locked(cifs_file);
361 spin_unlock(&cifs_file->file_info_lock);
362 return cifs_file;
363}
364
365
366
367
368
369
370void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
371{
372 _cifsFileInfo_put(cifs_file, true);
373}
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, bool wait_oplock_handler)
389{
390 struct inode *inode = d_inode(cifs_file->dentry);
391 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
392 struct TCP_Server_Info *server = tcon->ses->server;
393 struct cifsInodeInfo *cifsi = CIFS_I(inode);
394 struct super_block *sb = inode->i_sb;
395 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
396 struct cifsLockInfo *li, *tmp;
397 struct cifs_fid fid;
398 struct cifs_pending_open open;
399 bool oplock_break_cancelled;
400
401 spin_lock(&tcon->open_file_lock);
402
403 spin_lock(&cifs_file->file_info_lock);
404 if (--cifs_file->count > 0) {
405 spin_unlock(&cifs_file->file_info_lock);
406 spin_unlock(&tcon->open_file_lock);
407 return;
408 }
409 spin_unlock(&cifs_file->file_info_lock);
410
411 if (server->ops->get_lease_key)
412 server->ops->get_lease_key(inode, &fid);
413
414
415 cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
416
417
418 spin_lock(&cifsi->open_file_lock);
419 list_del(&cifs_file->flist);
420 spin_unlock(&cifsi->open_file_lock);
421 list_del(&cifs_file->tlist);
422 atomic_dec(&tcon->num_local_opens);
423
424 if (list_empty(&cifsi->openFileList)) {
425 cifs_dbg(FYI, "closing last open instance for inode %p\n",
426 d_inode(cifs_file->dentry));
427
428
429
430
431
432 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
433 set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
434 cifs_set_oplock_level(cifsi, 0);
435 }
436
437 spin_unlock(&tcon->open_file_lock);
438
439 oplock_break_cancelled = wait_oplock_handler ?
440 cancel_work_sync(&cifs_file->oplock_break) : false;
441
442 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
443 struct TCP_Server_Info *server = tcon->ses->server;
444 unsigned int xid;
445
446 xid = get_xid();
447 if (server->ops->close)
448 server->ops->close(xid, tcon, &cifs_file->fid);
449 _free_xid(xid);
450 }
451
452 if (oplock_break_cancelled)
453 cifs_done_oplock_break(cifsi);
454
455 cifs_del_pending_open(&open);
456
457
458
459
460
461 down_write(&cifsi->lock_sem);
462 list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
463 list_del(&li->llist);
464 cifs_del_lock_waiters(li);
465 kfree(li);
466 }
467 list_del(&cifs_file->llist->llist);
468 kfree(cifs_file->llist);
469 up_write(&cifsi->lock_sem);
470
471 cifs_put_tlink(cifs_file->tlink);
472 dput(cifs_file->dentry);
473 cifs_sb_deactive(sb);
474 kfree(cifs_file);
475}
476
477int cifs_open(struct inode *inode, struct file *file)
478
479{
480 int rc = -EACCES;
481 unsigned int xid;
482 __u32 oplock;
483 struct cifs_sb_info *cifs_sb;
484 struct TCP_Server_Info *server;
485 struct cifs_tcon *tcon;
486 struct tcon_link *tlink;
487 struct cifsFileInfo *cfile = NULL;
488 char *full_path = NULL;
489 bool posix_open_ok = false;
490 struct cifs_fid fid;
491 struct cifs_pending_open open;
492
493 xid = get_xid();
494
495 cifs_sb = CIFS_SB(inode->i_sb);
496 tlink = cifs_sb_tlink(cifs_sb);
497 if (IS_ERR(tlink)) {
498 free_xid(xid);
499 return PTR_ERR(tlink);
500 }
501 tcon = tlink_tcon(tlink);
502 server = tcon->ses->server;
503
504 full_path = build_path_from_dentry(file_dentry(file));
505 if (full_path == NULL) {
506 rc = -ENOMEM;
507 goto out;
508 }
509
510 cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
511 inode, file->f_flags, full_path);
512
513 if (file->f_flags & O_DIRECT &&
514 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
515 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
516 file->f_op = &cifs_file_direct_nobrl_ops;
517 else
518 file->f_op = &cifs_file_direct_ops;
519 }
520
521 if (server->oplocks)
522 oplock = REQ_OPLOCK;
523 else
524 oplock = 0;
525
526 if (!tcon->broken_posix_open && tcon->unix_ext &&
527 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
528 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
529
530 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
531 cifs_sb->mnt_file_mode ,
532 file->f_flags, &oplock, &fid.netfid, xid);
533 if (rc == 0) {
534 cifs_dbg(FYI, "posix open succeeded\n");
535 posix_open_ok = true;
536 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
537 if (tcon->ses->serverNOS)
538 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",
539 tcon->ses->serverName,
540 tcon->ses->serverNOS);
541 tcon->broken_posix_open = true;
542 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
543 (rc != -EOPNOTSUPP))
544 goto out;
545
546
547
548
549 }
550
551 if (server->ops->get_lease_key)
552 server->ops->get_lease_key(inode, &fid);
553
554 cifs_add_pending_open(&fid, tlink, &open);
555
556 if (!posix_open_ok) {
557 if (server->ops->get_lease_key)
558 server->ops->get_lease_key(inode, &fid);
559
560 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
561 file->f_flags, &oplock, &fid, xid);
562 if (rc) {
563 cifs_del_pending_open(&open);
564 goto out;
565 }
566 }
567
568 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
569 if (cfile == NULL) {
570 if (server->ops->close)
571 server->ops->close(xid, tcon, &fid);
572 cifs_del_pending_open(&open);
573 rc = -ENOMEM;
574 goto out;
575 }
576
577 cifs_fscache_set_inode_cookie(inode, file);
578
579 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
580
581
582
583
584 struct cifs_unix_set_info_args args = {
585 .mode = inode->i_mode,
586 .uid = INVALID_UID,
587 .gid = INVALID_GID,
588 .ctime = NO_CHANGE_64,
589 .atime = NO_CHANGE_64,
590 .mtime = NO_CHANGE_64,
591 .device = 0,
592 };
593 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
594 cfile->pid);
595 }
596
597out:
598 kfree(full_path);
599 free_xid(xid);
600 cifs_put_tlink(tlink);
601 return rc;
602}
603
604static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
605
606
607
608
609
610static int
611cifs_relock_file(struct cifsFileInfo *cfile)
612{
613 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
614 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
615 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
616 int rc = 0;
617
618 down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING);
619 if (cinode->can_cache_brlcks) {
620
621 up_read(&cinode->lock_sem);
622 return rc;
623 }
624
625 if (cap_unix(tcon->ses) &&
626 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
627 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
628 rc = cifs_push_posix_locks(cfile);
629 else
630 rc = tcon->ses->server->ops->push_mand_locks(cfile);
631
632 up_read(&cinode->lock_sem);
633 return rc;
634}
635
636static int
637cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
638{
639 int rc = -EACCES;
640 unsigned int xid;
641 __u32 oplock;
642 struct cifs_sb_info *cifs_sb;
643 struct cifs_tcon *tcon;
644 struct TCP_Server_Info *server;
645 struct cifsInodeInfo *cinode;
646 struct inode *inode;
647 char *full_path = NULL;
648 int desired_access;
649 int disposition = FILE_OPEN;
650 int create_options = CREATE_NOT_DIR;
651 struct cifs_open_parms oparms;
652
653 xid = get_xid();
654 mutex_lock(&cfile->fh_mutex);
655 if (!cfile->invalidHandle) {
656 mutex_unlock(&cfile->fh_mutex);
657 rc = 0;
658 free_xid(xid);
659 return rc;
660 }
661
662 inode = d_inode(cfile->dentry);
663 cifs_sb = CIFS_SB(inode->i_sb);
664 tcon = tlink_tcon(cfile->tlink);
665 server = tcon->ses->server;
666
667
668
669
670
671
672
673 full_path = build_path_from_dentry(cfile->dentry);
674 if (full_path == NULL) {
675 rc = -ENOMEM;
676 mutex_unlock(&cfile->fh_mutex);
677 free_xid(xid);
678 return rc;
679 }
680
681 cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
682 inode, cfile->f_flags, full_path);
683
684 if (tcon->ses->server->oplocks)
685 oplock = REQ_OPLOCK;
686 else
687 oplock = 0;
688
689 if (tcon->unix_ext && cap_unix(tcon->ses) &&
690 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
691 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
692
693
694
695
696 unsigned int oflags = cfile->f_flags &
697 ~(O_CREAT | O_EXCL | O_TRUNC);
698
699 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
700 cifs_sb->mnt_file_mode ,
701 oflags, &oplock, &cfile->fid.netfid, xid);
702 if (rc == 0) {
703 cifs_dbg(FYI, "posix reopen succeeded\n");
704 oparms.reconnect = true;
705 goto reopen_success;
706 }
707
708
709
710
711 }
712
713 desired_access = cifs_convert_flags(cfile->f_flags);
714
715 if (backup_cred(cifs_sb))
716 create_options |= CREATE_OPEN_BACKUP_INTENT;
717
718 if (server->ops->get_lease_key)
719 server->ops->get_lease_key(inode, &cfile->fid);
720
721 oparms.tcon = tcon;
722 oparms.cifs_sb = cifs_sb;
723 oparms.desired_access = desired_access;
724 oparms.create_options = create_options;
725 oparms.disposition = disposition;
726 oparms.path = full_path;
727 oparms.fid = &cfile->fid;
728 oparms.reconnect = true;
729
730
731
732
733
734
735
736
737 rc = server->ops->open(xid, &oparms, &oplock, NULL);
738 if (rc == -ENOENT && oparms.reconnect == false) {
739
740 rc = server->ops->open(xid, &oparms, &oplock, NULL);
741
742 oparms.reconnect = true;
743 }
744
745 if (rc) {
746 mutex_unlock(&cfile->fh_mutex);
747 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
748 cifs_dbg(FYI, "oplock: %d\n", oplock);
749 goto reopen_error_exit;
750 }
751
752reopen_success:
753 cfile->invalidHandle = false;
754 mutex_unlock(&cfile->fh_mutex);
755 cinode = CIFS_I(inode);
756
757 if (can_flush) {
758 rc = filemap_write_and_wait(inode->i_mapping);
759 if (!is_interrupt_error(rc))
760 mapping_set_error(inode->i_mapping, rc);
761
762 if (tcon->unix_ext)
763 rc = cifs_get_inode_info_unix(&inode, full_path,
764 inode->i_sb, xid);
765 else
766 rc = cifs_get_inode_info(&inode, full_path, NULL,
767 inode->i_sb, xid, NULL);
768 }
769
770
771
772
773
774
775
776
777
778
779
780 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
781 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
782 oplock = 0;
783 }
784
785 server->ops->set_fid(cfile, &cfile->fid, oplock);
786 if (oparms.reconnect)
787 cifs_relock_file(cfile);
788
789reopen_error_exit:
790 kfree(full_path);
791 free_xid(xid);
792 return rc;
793}
794
795int cifs_close(struct inode *inode, struct file *file)
796{
797 if (file->private_data != NULL) {
798 cifsFileInfo_put(file->private_data);
799 file->private_data = NULL;
800 }
801
802
803 return 0;
804}
805
806void
807cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
808{
809 struct cifsFileInfo *open_file;
810 struct list_head *tmp;
811 struct list_head *tmp1;
812 struct list_head tmp_list;
813
814 if (!tcon->use_persistent || !tcon->need_reopen_files)
815 return;
816
817 tcon->need_reopen_files = false;
818
819 cifs_dbg(FYI, "Reopen persistent handles");
820 INIT_LIST_HEAD(&tmp_list);
821
822
823 spin_lock(&tcon->open_file_lock);
824 list_for_each(tmp, &tcon->openFileList) {
825 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
826 if (!open_file->invalidHandle)
827 continue;
828 cifsFileInfo_get(open_file);
829 list_add_tail(&open_file->rlist, &tmp_list);
830 }
831 spin_unlock(&tcon->open_file_lock);
832
833 list_for_each_safe(tmp, tmp1, &tmp_list) {
834 open_file = list_entry(tmp, struct cifsFileInfo, rlist);
835 if (cifs_reopen_file(open_file, false ))
836 tcon->need_reopen_files = true;
837 list_del_init(&open_file->rlist);
838 cifsFileInfo_put(open_file);
839 }
840}
841
842int cifs_closedir(struct inode *inode, struct file *file)
843{
844 int rc = 0;
845 unsigned int xid;
846 struct cifsFileInfo *cfile = file->private_data;
847 struct cifs_tcon *tcon;
848 struct TCP_Server_Info *server;
849 char *buf;
850
851 cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
852
853 if (cfile == NULL)
854 return rc;
855
856 xid = get_xid();
857 tcon = tlink_tcon(cfile->tlink);
858 server = tcon->ses->server;
859
860 cifs_dbg(FYI, "Freeing private data in close dir\n");
861 spin_lock(&cfile->file_info_lock);
862 if (server->ops->dir_needs_close(cfile)) {
863 cfile->invalidHandle = true;
864 spin_unlock(&cfile->file_info_lock);
865 if (server->ops->close_dir)
866 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
867 else
868 rc = -ENOSYS;
869 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
870
871 rc = 0;
872 } else
873 spin_unlock(&cfile->file_info_lock);
874
875 buf = cfile->srch_inf.ntwrk_buf_start;
876 if (buf) {
877 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
878 cfile->srch_inf.ntwrk_buf_start = NULL;
879 if (cfile->srch_inf.smallBuf)
880 cifs_small_buf_release(buf);
881 else
882 cifs_buf_release(buf);
883 }
884
885 cifs_put_tlink(cfile->tlink);
886 kfree(file->private_data);
887 file->private_data = NULL;
888
889 free_xid(xid);
890 return rc;
891}
892
893static struct cifsLockInfo *
894cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 flags)
895{
896 struct cifsLockInfo *lock =
897 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
898 if (!lock)
899 return lock;
900 lock->offset = offset;
901 lock->length = length;
902 lock->type = type;
903 lock->pid = current->tgid;
904 lock->flags = flags;
905 INIT_LIST_HEAD(&lock->blist);
906 init_waitqueue_head(&lock->block_q);
907 return lock;
908}
909
910void
911cifs_del_lock_waiters(struct cifsLockInfo *lock)
912{
913 struct cifsLockInfo *li, *tmp;
914 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
915 list_del_init(&li->blist);
916 wake_up(&li->block_q);
917 }
918}
919
920#define CIFS_LOCK_OP 0
921#define CIFS_READ_OP 1
922#define CIFS_WRITE_OP 2
923
924
925static bool
926cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
927 __u64 length, __u8 type, __u16 flags,
928 struct cifsFileInfo *cfile,
929 struct cifsLockInfo **conf_lock, int rw_check)
930{
931 struct cifsLockInfo *li;
932 struct cifsFileInfo *cur_cfile = fdlocks->cfile;
933 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
934
935 list_for_each_entry(li, &fdlocks->locks, llist) {
936 if (offset + length <= li->offset ||
937 offset >= li->offset + li->length)
938 continue;
939 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
940 server->ops->compare_fids(cfile, cur_cfile)) {
941
942 if (!(li->type & server->vals->shared_lock_type) ||
943 rw_check != CIFS_WRITE_OP)
944 continue;
945 }
946 if ((type & server->vals->shared_lock_type) &&
947 ((server->ops->compare_fids(cfile, cur_cfile) &&
948 current->tgid == li->pid) || type == li->type))
949 continue;
950 if (rw_check == CIFS_LOCK_OP &&
951 (flags & FL_OFDLCK) && (li->flags & FL_OFDLCK) &&
952 server->ops->compare_fids(cfile, cur_cfile))
953 continue;
954 if (conf_lock)
955 *conf_lock = li;
956 return true;
957 }
958 return false;
959}
960
961bool
962cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
963 __u8 type, __u16 flags,
964 struct cifsLockInfo **conf_lock, int rw_check)
965{
966 bool rc = false;
967 struct cifs_fid_locks *cur;
968 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
969
970 list_for_each_entry(cur, &cinode->llist, llist) {
971 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
972 flags, cfile, conf_lock,
973 rw_check);
974 if (rc)
975 break;
976 }
977
978 return rc;
979}
980
981
982
983
984
985
986
987
988static int
989cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
990 __u8 type, struct file_lock *flock)
991{
992 int rc = 0;
993 struct cifsLockInfo *conf_lock;
994 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
995 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
996 bool exist;
997
998 down_read(&cinode->lock_sem);
999
1000 exist = cifs_find_lock_conflict(cfile, offset, length, type,
1001 flock->fl_flags, &conf_lock,
1002 CIFS_LOCK_OP);
1003 if (exist) {
1004 flock->fl_start = conf_lock->offset;
1005 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
1006 flock->fl_pid = conf_lock->pid;
1007 if (conf_lock->type & server->vals->shared_lock_type)
1008 flock->fl_type = F_RDLCK;
1009 else
1010 flock->fl_type = F_WRLCK;
1011 } else if (!cinode->can_cache_brlcks)
1012 rc = 1;
1013 else
1014 flock->fl_type = F_UNLCK;
1015
1016 up_read(&cinode->lock_sem);
1017 return rc;
1018}
1019
1020static void
1021cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
1022{
1023 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1024 down_write(&cinode->lock_sem);
1025 list_add_tail(&lock->llist, &cfile->llist->locks);
1026 up_write(&cinode->lock_sem);
1027}
1028
1029
1030
1031
1032
1033
1034
1035static int
1036cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
1037 bool wait)
1038{
1039 struct cifsLockInfo *conf_lock;
1040 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1041 bool exist;
1042 int rc = 0;
1043
1044try_again:
1045 exist = false;
1046 down_write(&cinode->lock_sem);
1047
1048 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1049 lock->type, lock->flags, &conf_lock,
1050 CIFS_LOCK_OP);
1051 if (!exist && cinode->can_cache_brlcks) {
1052 list_add_tail(&lock->llist, &cfile->llist->locks);
1053 up_write(&cinode->lock_sem);
1054 return rc;
1055 }
1056
1057 if (!exist)
1058 rc = 1;
1059 else if (!wait)
1060 rc = -EACCES;
1061 else {
1062 list_add_tail(&lock->blist, &conf_lock->blist);
1063 up_write(&cinode->lock_sem);
1064 rc = wait_event_interruptible(lock->block_q,
1065 (lock->blist.prev == &lock->blist) &&
1066 (lock->blist.next == &lock->blist));
1067 if (!rc)
1068 goto try_again;
1069 down_write(&cinode->lock_sem);
1070 list_del_init(&lock->blist);
1071 }
1072
1073 up_write(&cinode->lock_sem);
1074 return rc;
1075}
1076
1077
1078
1079
1080
1081
1082
1083
1084static int
1085cifs_posix_lock_test(struct file *file, struct file_lock *flock)
1086{
1087 int rc = 0;
1088 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1089 unsigned char saved_type = flock->fl_type;
1090
1091 if ((flock->fl_flags & FL_POSIX) == 0)
1092 return 1;
1093
1094 down_read(&cinode->lock_sem);
1095 posix_test_lock(file, flock);
1096
1097 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1098 flock->fl_type = saved_type;
1099 rc = 1;
1100 }
1101
1102 up_read(&cinode->lock_sem);
1103 return rc;
1104}
1105
1106
1107
1108
1109
1110
1111
1112static int
1113cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1114{
1115 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1116 int rc = 1;
1117
1118 if ((flock->fl_flags & FL_POSIX) == 0)
1119 return rc;
1120
1121try_again:
1122 down_write(&cinode->lock_sem);
1123 if (!cinode->can_cache_brlcks) {
1124 up_write(&cinode->lock_sem);
1125 return rc;
1126 }
1127
1128 rc = posix_lock_file(file, flock, NULL);
1129 up_write(&cinode->lock_sem);
1130 if (rc == FILE_LOCK_DEFERRED) {
1131 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_blocker);
1132 if (!rc)
1133 goto try_again;
1134 locks_delete_block(flock);
1135 }
1136 return rc;
1137}
1138
1139int
1140cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1141{
1142 unsigned int xid;
1143 int rc = 0, stored_rc;
1144 struct cifsLockInfo *li, *tmp;
1145 struct cifs_tcon *tcon;
1146 unsigned int num, max_num, max_buf;
1147 LOCKING_ANDX_RANGE *buf, *cur;
1148 static const int types[] = {
1149 LOCKING_ANDX_LARGE_FILES,
1150 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1151 };
1152 int i;
1153
1154 xid = get_xid();
1155 tcon = tlink_tcon(cfile->tlink);
1156
1157
1158
1159
1160
1161 max_buf = tcon->ses->server->maxBuf;
1162 if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) {
1163 free_xid(xid);
1164 return -EINVAL;
1165 }
1166
1167 BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1168 PAGE_SIZE);
1169 max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1170 PAGE_SIZE);
1171 max_num = (max_buf - sizeof(struct smb_hdr)) /
1172 sizeof(LOCKING_ANDX_RANGE);
1173 buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1174 if (!buf) {
1175 free_xid(xid);
1176 return -ENOMEM;
1177 }
1178
1179 for (i = 0; i < 2; i++) {
1180 cur = buf;
1181 num = 0;
1182 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1183 if (li->type != types[i])
1184 continue;
1185 cur->Pid = cpu_to_le16(li->pid);
1186 cur->LengthLow = cpu_to_le32((u32)li->length);
1187 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1188 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1189 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1190 if (++num == max_num) {
1191 stored_rc = cifs_lockv(xid, tcon,
1192 cfile->fid.netfid,
1193 (__u8)li->type, 0, num,
1194 buf);
1195 if (stored_rc)
1196 rc = stored_rc;
1197 cur = buf;
1198 num = 0;
1199 } else
1200 cur++;
1201 }
1202
1203 if (num) {
1204 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1205 (__u8)types[i], 0, num, buf);
1206 if (stored_rc)
1207 rc = stored_rc;
1208 }
1209 }
1210
1211 kfree(buf);
1212 free_xid(xid);
1213 return rc;
1214}
1215
1216static __u32
1217hash_lockowner(fl_owner_t owner)
1218{
1219 return cifs_lock_secret ^ hash32_ptr((const void *)owner);
1220}
1221
1222struct lock_to_push {
1223 struct list_head llist;
1224 __u64 offset;
1225 __u64 length;
1226 __u32 pid;
1227 __u16 netfid;
1228 __u8 type;
1229};
1230
1231static int
1232cifs_push_posix_locks(struct cifsFileInfo *cfile)
1233{
1234 struct inode *inode = d_inode(cfile->dentry);
1235 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1236 struct file_lock *flock;
1237 struct file_lock_context *flctx = inode->i_flctx;
1238 unsigned int count = 0, i;
1239 int rc = 0, xid, type;
1240 struct list_head locks_to_send, *el;
1241 struct lock_to_push *lck, *tmp;
1242 __u64 length;
1243
1244 xid = get_xid();
1245
1246 if (!flctx)
1247 goto out;
1248
1249 spin_lock(&flctx->flc_lock);
1250 list_for_each(el, &flctx->flc_posix) {
1251 count++;
1252 }
1253 spin_unlock(&flctx->flc_lock);
1254
1255 INIT_LIST_HEAD(&locks_to_send);
1256
1257
1258
1259
1260
1261
1262 for (i = 0; i < count; i++) {
1263 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1264 if (!lck) {
1265 rc = -ENOMEM;
1266 goto err_out;
1267 }
1268 list_add_tail(&lck->llist, &locks_to_send);
1269 }
1270
1271 el = locks_to_send.next;
1272 spin_lock(&flctx->flc_lock);
1273 list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1274 if (el == &locks_to_send) {
1275
1276
1277
1278
1279 cifs_dbg(VFS, "Can't push all brlocks!\n");
1280 break;
1281 }
1282 length = 1 + flock->fl_end - flock->fl_start;
1283 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1284 type = CIFS_RDLCK;
1285 else
1286 type = CIFS_WRLCK;
1287 lck = list_entry(el, struct lock_to_push, llist);
1288 lck->pid = hash_lockowner(flock->fl_owner);
1289 lck->netfid = cfile->fid.netfid;
1290 lck->length = length;
1291 lck->type = type;
1292 lck->offset = flock->fl_start;
1293 }
1294 spin_unlock(&flctx->flc_lock);
1295
1296 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1297 int stored_rc;
1298
1299 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1300 lck->offset, lck->length, NULL,
1301 lck->type, 0);
1302 if (stored_rc)
1303 rc = stored_rc;
1304 list_del(&lck->llist);
1305 kfree(lck);
1306 }
1307
1308out:
1309 free_xid(xid);
1310 return rc;
1311err_out:
1312 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1313 list_del(&lck->llist);
1314 kfree(lck);
1315 }
1316 goto out;
1317}
1318
1319static int
1320cifs_push_locks(struct cifsFileInfo *cfile)
1321{
1322 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1323 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1324 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1325 int rc = 0;
1326
1327
1328 down_write(&cinode->lock_sem);
1329 if (!cinode->can_cache_brlcks) {
1330 up_write(&cinode->lock_sem);
1331 return rc;
1332 }
1333
1334 if (cap_unix(tcon->ses) &&
1335 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1336 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1337 rc = cifs_push_posix_locks(cfile);
1338 else
1339 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1340
1341 cinode->can_cache_brlcks = false;
1342 up_write(&cinode->lock_sem);
1343 return rc;
1344}
1345
1346static void
1347cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1348 bool *wait_flag, struct TCP_Server_Info *server)
1349{
1350 if (flock->fl_flags & FL_POSIX)
1351 cifs_dbg(FYI, "Posix\n");
1352 if (flock->fl_flags & FL_FLOCK)
1353 cifs_dbg(FYI, "Flock\n");
1354 if (flock->fl_flags & FL_SLEEP) {
1355 cifs_dbg(FYI, "Blocking lock\n");
1356 *wait_flag = true;
1357 }
1358 if (flock->fl_flags & FL_ACCESS)
1359 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1360 if (flock->fl_flags & FL_LEASE)
1361 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1362 if (flock->fl_flags &
1363 (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1364 FL_ACCESS | FL_LEASE | FL_CLOSE | FL_OFDLCK)))
1365 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1366
1367 *type = server->vals->large_lock_type;
1368 if (flock->fl_type == F_WRLCK) {
1369 cifs_dbg(FYI, "F_WRLCK\n");
1370 *type |= server->vals->exclusive_lock_type;
1371 *lock = 1;
1372 } else if (flock->fl_type == F_UNLCK) {
1373 cifs_dbg(FYI, "F_UNLCK\n");
1374 *type |= server->vals->unlock_lock_type;
1375 *unlock = 1;
1376
1377 } else if (flock->fl_type == F_RDLCK) {
1378 cifs_dbg(FYI, "F_RDLCK\n");
1379 *type |= server->vals->shared_lock_type;
1380 *lock = 1;
1381 } else if (flock->fl_type == F_EXLCK) {
1382 cifs_dbg(FYI, "F_EXLCK\n");
1383 *type |= server->vals->exclusive_lock_type;
1384 *lock = 1;
1385 } else if (flock->fl_type == F_SHLCK) {
1386 cifs_dbg(FYI, "F_SHLCK\n");
1387 *type |= server->vals->shared_lock_type;
1388 *lock = 1;
1389 } else
1390 cifs_dbg(FYI, "Unknown type of lock\n");
1391}
1392
1393static int
1394cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1395 bool wait_flag, bool posix_lck, unsigned int xid)
1396{
1397 int rc = 0;
1398 __u64 length = 1 + flock->fl_end - flock->fl_start;
1399 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1400 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1401 struct TCP_Server_Info *server = tcon->ses->server;
1402 __u16 netfid = cfile->fid.netfid;
1403
1404 if (posix_lck) {
1405 int posix_lock_type;
1406
1407 rc = cifs_posix_lock_test(file, flock);
1408 if (!rc)
1409 return rc;
1410
1411 if (type & server->vals->shared_lock_type)
1412 posix_lock_type = CIFS_RDLCK;
1413 else
1414 posix_lock_type = CIFS_WRLCK;
1415 rc = CIFSSMBPosixLock(xid, tcon, netfid,
1416 hash_lockowner(flock->fl_owner),
1417 flock->fl_start, length, flock,
1418 posix_lock_type, wait_flag);
1419 return rc;
1420 }
1421
1422 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1423 if (!rc)
1424 return rc;
1425
1426
1427 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1428 1, 0, false);
1429 if (rc == 0) {
1430 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1431 type, 0, 1, false);
1432 flock->fl_type = F_UNLCK;
1433 if (rc != 0)
1434 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1435 rc);
1436 return 0;
1437 }
1438
1439 if (type & server->vals->shared_lock_type) {
1440 flock->fl_type = F_WRLCK;
1441 return 0;
1442 }
1443
1444 type &= ~server->vals->exclusive_lock_type;
1445
1446 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1447 type | server->vals->shared_lock_type,
1448 1, 0, false);
1449 if (rc == 0) {
1450 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1451 type | server->vals->shared_lock_type, 0, 1, false);
1452 flock->fl_type = F_RDLCK;
1453 if (rc != 0)
1454 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1455 rc);
1456 } else
1457 flock->fl_type = F_WRLCK;
1458
1459 return 0;
1460}
1461
1462void
1463cifs_move_llist(struct list_head *source, struct list_head *dest)
1464{
1465 struct list_head *li, *tmp;
1466 list_for_each_safe(li, tmp, source)
1467 list_move(li, dest);
1468}
1469
1470void
1471cifs_free_llist(struct list_head *llist)
1472{
1473 struct cifsLockInfo *li, *tmp;
1474 list_for_each_entry_safe(li, tmp, llist, llist) {
1475 cifs_del_lock_waiters(li);
1476 list_del(&li->llist);
1477 kfree(li);
1478 }
1479}
1480
1481int
1482cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1483 unsigned int xid)
1484{
1485 int rc = 0, stored_rc;
1486 static const int types[] = {
1487 LOCKING_ANDX_LARGE_FILES,
1488 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1489 };
1490 unsigned int i;
1491 unsigned int max_num, num, max_buf;
1492 LOCKING_ANDX_RANGE *buf, *cur;
1493 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1494 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1495 struct cifsLockInfo *li, *tmp;
1496 __u64 length = 1 + flock->fl_end - flock->fl_start;
1497 struct list_head tmp_llist;
1498
1499 INIT_LIST_HEAD(&tmp_llist);
1500
1501
1502
1503
1504
1505 max_buf = tcon->ses->server->maxBuf;
1506 if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE)))
1507 return -EINVAL;
1508
1509 BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1510 PAGE_SIZE);
1511 max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1512 PAGE_SIZE);
1513 max_num = (max_buf - sizeof(struct smb_hdr)) /
1514 sizeof(LOCKING_ANDX_RANGE);
1515 buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1516 if (!buf)
1517 return -ENOMEM;
1518
1519 down_write(&cinode->lock_sem);
1520 for (i = 0; i < 2; i++) {
1521 cur = buf;
1522 num = 0;
1523 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1524 if (flock->fl_start > li->offset ||
1525 (flock->fl_start + length) <
1526 (li->offset + li->length))
1527 continue;
1528 if (current->tgid != li->pid)
1529 continue;
1530 if (types[i] != li->type)
1531 continue;
1532 if (cinode->can_cache_brlcks) {
1533
1534
1535
1536
1537 list_del(&li->llist);
1538 cifs_del_lock_waiters(li);
1539 kfree(li);
1540 continue;
1541 }
1542 cur->Pid = cpu_to_le16(li->pid);
1543 cur->LengthLow = cpu_to_le32((u32)li->length);
1544 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1545 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1546 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1547
1548
1549
1550
1551
1552 list_move(&li->llist, &tmp_llist);
1553 if (++num == max_num) {
1554 stored_rc = cifs_lockv(xid, tcon,
1555 cfile->fid.netfid,
1556 li->type, num, 0, buf);
1557 if (stored_rc) {
1558
1559
1560
1561
1562
1563 cifs_move_llist(&tmp_llist,
1564 &cfile->llist->locks);
1565 rc = stored_rc;
1566 } else
1567
1568
1569
1570
1571 cifs_free_llist(&tmp_llist);
1572 cur = buf;
1573 num = 0;
1574 } else
1575 cur++;
1576 }
1577 if (num) {
1578 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1579 types[i], num, 0, buf);
1580 if (stored_rc) {
1581 cifs_move_llist(&tmp_llist,
1582 &cfile->llist->locks);
1583 rc = stored_rc;
1584 } else
1585 cifs_free_llist(&tmp_llist);
1586 }
1587 }
1588
1589 up_write(&cinode->lock_sem);
1590 kfree(buf);
1591 return rc;
1592}
1593
1594static int
1595cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1596 bool wait_flag, bool posix_lck, int lock, int unlock,
1597 unsigned int xid)
1598{
1599 int rc = 0;
1600 __u64 length = 1 + flock->fl_end - flock->fl_start;
1601 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1602 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1603 struct TCP_Server_Info *server = tcon->ses->server;
1604 struct inode *inode = d_inode(cfile->dentry);
1605
1606 if (posix_lck) {
1607 int posix_lock_type;
1608
1609 rc = cifs_posix_lock_set(file, flock);
1610 if (!rc || rc < 0)
1611 return rc;
1612
1613 if (type & server->vals->shared_lock_type)
1614 posix_lock_type = CIFS_RDLCK;
1615 else
1616 posix_lock_type = CIFS_WRLCK;
1617
1618 if (unlock == 1)
1619 posix_lock_type = CIFS_UNLCK;
1620
1621 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1622 hash_lockowner(flock->fl_owner),
1623 flock->fl_start, length,
1624 NULL, posix_lock_type, wait_flag);
1625 goto out;
1626 }
1627
1628 if (lock) {
1629 struct cifsLockInfo *lock;
1630
1631 lock = cifs_lock_init(flock->fl_start, length, type,
1632 flock->fl_flags);
1633 if (!lock)
1634 return -ENOMEM;
1635
1636 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1637 if (rc < 0) {
1638 kfree(lock);
1639 return rc;
1640 }
1641 if (!rc)
1642 goto out;
1643
1644
1645
1646
1647
1648
1649
1650
1651 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1652 CIFS_CACHE_READ(CIFS_I(inode))) {
1653 cifs_zap_mapping(inode);
1654 cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1655 inode);
1656 CIFS_I(inode)->oplock = 0;
1657 }
1658
1659 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1660 type, 1, 0, wait_flag);
1661 if (rc) {
1662 kfree(lock);
1663 return rc;
1664 }
1665
1666 cifs_lock_add(cfile, lock);
1667 } else if (unlock)
1668 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1669
1670out:
1671 if (flock->fl_flags & FL_POSIX) {
1672
1673
1674
1675
1676
1677
1678 if (rc) {
1679 cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc);
1680 if (!(flock->fl_flags & FL_CLOSE))
1681 return rc;
1682 }
1683 rc = locks_lock_file_wait(file, flock);
1684 }
1685 return rc;
1686}
1687
1688int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1689{
1690 int rc, xid;
1691 int lock = 0, unlock = 0;
1692 bool wait_flag = false;
1693 bool posix_lck = false;
1694 struct cifs_sb_info *cifs_sb;
1695 struct cifs_tcon *tcon;
1696 struct cifsInodeInfo *cinode;
1697 struct cifsFileInfo *cfile;
1698 __u16 netfid;
1699 __u32 type;
1700
1701 rc = -EACCES;
1702 xid = get_xid();
1703
1704 cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1705 cmd, flock->fl_flags, flock->fl_type,
1706 flock->fl_start, flock->fl_end);
1707
1708 cfile = (struct cifsFileInfo *)file->private_data;
1709 tcon = tlink_tcon(cfile->tlink);
1710
1711 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1712 tcon->ses->server);
1713 cifs_sb = CIFS_FILE_SB(file);
1714 netfid = cfile->fid.netfid;
1715 cinode = CIFS_I(file_inode(file));
1716
1717 if (cap_unix(tcon->ses) &&
1718 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1719 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1720 posix_lck = true;
1721
1722
1723
1724
1725 if (IS_GETLK(cmd)) {
1726 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1727 free_xid(xid);
1728 return rc;
1729 }
1730
1731 if (!lock && !unlock) {
1732
1733
1734
1735
1736 free_xid(xid);
1737 return -EOPNOTSUPP;
1738 }
1739
1740 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1741 xid);
1742 free_xid(xid);
1743 return rc;
1744}
1745
1746
1747
1748
1749
1750void
1751cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1752 unsigned int bytes_written)
1753{
1754 loff_t end_of_write = offset + bytes_written;
1755
1756 if (end_of_write > cifsi->server_eof)
1757 cifsi->server_eof = end_of_write;
1758}
1759
1760static ssize_t
1761cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1762 size_t write_size, loff_t *offset)
1763{
1764 int rc = 0;
1765 unsigned int bytes_written = 0;
1766 unsigned int total_written;
1767 struct cifs_sb_info *cifs_sb;
1768 struct cifs_tcon *tcon;
1769 struct TCP_Server_Info *server;
1770 unsigned int xid;
1771 struct dentry *dentry = open_file->dentry;
1772 struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1773 struct cifs_io_parms io_parms;
1774
1775 cifs_sb = CIFS_SB(dentry->d_sb);
1776
1777 cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
1778 write_size, *offset, dentry);
1779
1780 tcon = tlink_tcon(open_file->tlink);
1781 server = tcon->ses->server;
1782
1783 if (!server->ops->sync_write)
1784 return -ENOSYS;
1785
1786 xid = get_xid();
1787
1788 for (total_written = 0; write_size > total_written;
1789 total_written += bytes_written) {
1790 rc = -EAGAIN;
1791 while (rc == -EAGAIN) {
1792 struct kvec iov[2];
1793 unsigned int len;
1794
1795 if (open_file->invalidHandle) {
1796
1797
1798
1799
1800 rc = cifs_reopen_file(open_file, false);
1801 if (rc != 0)
1802 break;
1803 }
1804
1805 len = min(server->ops->wp_retry_size(d_inode(dentry)),
1806 (unsigned int)write_size - total_written);
1807
1808 iov[1].iov_base = (char *)write_data + total_written;
1809 iov[1].iov_len = len;
1810 io_parms.pid = pid;
1811 io_parms.tcon = tcon;
1812 io_parms.offset = *offset;
1813 io_parms.length = len;
1814 rc = server->ops->sync_write(xid, &open_file->fid,
1815 &io_parms, &bytes_written, iov, 1);
1816 }
1817 if (rc || (bytes_written == 0)) {
1818 if (total_written)
1819 break;
1820 else {
1821 free_xid(xid);
1822 return rc;
1823 }
1824 } else {
1825 spin_lock(&d_inode(dentry)->i_lock);
1826 cifs_update_eof(cifsi, *offset, bytes_written);
1827 spin_unlock(&d_inode(dentry)->i_lock);
1828 *offset += bytes_written;
1829 }
1830 }
1831
1832 cifs_stats_bytes_written(tcon, total_written);
1833
1834 if (total_written > 0) {
1835 spin_lock(&d_inode(dentry)->i_lock);
1836 if (*offset > d_inode(dentry)->i_size)
1837 i_size_write(d_inode(dentry), *offset);
1838 spin_unlock(&d_inode(dentry)->i_lock);
1839 }
1840 mark_inode_dirty_sync(d_inode(dentry));
1841 free_xid(xid);
1842 return total_written;
1843}
1844
1845struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1846 bool fsuid_only)
1847{
1848 struct cifsFileInfo *open_file = NULL;
1849 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1850 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1851
1852
1853 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1854 fsuid_only = false;
1855
1856 spin_lock(&tcon->open_file_lock);
1857
1858
1859
1860 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1861 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1862 continue;
1863 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1864 if (!open_file->invalidHandle) {
1865
1866
1867 cifsFileInfo_get(open_file);
1868 spin_unlock(&tcon->open_file_lock);
1869 return open_file;
1870 }
1871
1872
1873 } else
1874 break;
1875 }
1876 spin_unlock(&tcon->open_file_lock);
1877 return NULL;
1878}
1879
1880
1881int
1882cifs_get_writable_file(struct cifsInodeInfo *cifs_inode, bool fsuid_only,
1883 struct cifsFileInfo **ret_file)
1884{
1885 struct cifsFileInfo *open_file, *inv_file = NULL;
1886 struct cifs_sb_info *cifs_sb;
1887 struct cifs_tcon *tcon;
1888 bool any_available = false;
1889 int rc = -EBADF;
1890 unsigned int refind = 0;
1891
1892 *ret_file = NULL;
1893
1894
1895
1896
1897
1898
1899
1900 if (cifs_inode == NULL) {
1901 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1902 dump_stack();
1903 return rc;
1904 }
1905
1906 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1907 tcon = cifs_sb_master_tcon(cifs_sb);
1908
1909
1910 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1911 fsuid_only = false;
1912
1913 spin_lock(&tcon->open_file_lock);
1914refind_writable:
1915 if (refind > MAX_REOPEN_ATT) {
1916 spin_unlock(&tcon->open_file_lock);
1917 return rc;
1918 }
1919 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1920 if (!any_available && open_file->pid != current->tgid)
1921 continue;
1922 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1923 continue;
1924 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1925 if (!open_file->invalidHandle) {
1926
1927 cifsFileInfo_get(open_file);
1928 spin_unlock(&tcon->open_file_lock);
1929 *ret_file = open_file;
1930 return 0;
1931 } else {
1932 if (!inv_file)
1933 inv_file = open_file;
1934 }
1935 }
1936 }
1937
1938 if (!any_available) {
1939 any_available = true;
1940 goto refind_writable;
1941 }
1942
1943 if (inv_file) {
1944 any_available = false;
1945 cifsFileInfo_get(inv_file);
1946 }
1947
1948 spin_unlock(&tcon->open_file_lock);
1949
1950 if (inv_file) {
1951 rc = cifs_reopen_file(inv_file, false);
1952 if (!rc) {
1953 *ret_file = inv_file;
1954 return 0;
1955 }
1956
1957 spin_lock(&cifs_inode->open_file_lock);
1958 list_move_tail(&inv_file->flist, &cifs_inode->openFileList);
1959 spin_unlock(&cifs_inode->open_file_lock);
1960 cifsFileInfo_put(inv_file);
1961 ++refind;
1962 inv_file = NULL;
1963 spin_lock(&tcon->open_file_lock);
1964 goto refind_writable;
1965 }
1966
1967 return rc;
1968}
1969
1970struct cifsFileInfo *
1971find_writable_file(struct cifsInodeInfo *cifs_inode, bool fsuid_only)
1972{
1973 struct cifsFileInfo *cfile;
1974 int rc;
1975
1976 rc = cifs_get_writable_file(cifs_inode, fsuid_only, &cfile);
1977 if (rc)
1978 cifs_dbg(FYI, "couldn't find writable handle rc=%d", rc);
1979
1980 return cfile;
1981}
1982
1983static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1984{
1985 struct address_space *mapping = page->mapping;
1986 loff_t offset = (loff_t)page->index << PAGE_SHIFT;
1987 char *write_data;
1988 int rc = -EFAULT;
1989 int bytes_written = 0;
1990 struct inode *inode;
1991 struct cifsFileInfo *open_file;
1992
1993 if (!mapping || !mapping->host)
1994 return -EFAULT;
1995
1996 inode = page->mapping->host;
1997
1998 offset += (loff_t)from;
1999 write_data = kmap(page);
2000 write_data += from;
2001
2002 if ((to > PAGE_SIZE) || (from > to)) {
2003 kunmap(page);
2004 return -EIO;
2005 }
2006
2007
2008 if (offset > mapping->host->i_size) {
2009 kunmap(page);
2010 return 0;
2011 }
2012
2013
2014 if (mapping->host->i_size - offset < (loff_t)to)
2015 to = (unsigned)(mapping->host->i_size - offset);
2016
2017 rc = cifs_get_writable_file(CIFS_I(mapping->host), false, &open_file);
2018 if (!rc) {
2019 bytes_written = cifs_write(open_file, open_file->pid,
2020 write_data, to - from, &offset);
2021 cifsFileInfo_put(open_file);
2022
2023 inode->i_atime = inode->i_mtime = current_time(inode);
2024 if ((bytes_written > 0) && (offset))
2025 rc = 0;
2026 else if (bytes_written < 0)
2027 rc = bytes_written;
2028 else
2029 rc = -EFAULT;
2030 } else {
2031 cifs_dbg(FYI, "No writable handle for write page rc=%d\n", rc);
2032 if (!is_retryable_error(rc))
2033 rc = -EIO;
2034 }
2035
2036 kunmap(page);
2037 return rc;
2038}
2039
2040static struct cifs_writedata *
2041wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
2042 pgoff_t end, pgoff_t *index,
2043 unsigned int *found_pages)
2044{
2045 struct cifs_writedata *wdata;
2046
2047 wdata = cifs_writedata_alloc((unsigned int)tofind,
2048 cifs_writev_complete);
2049 if (!wdata)
2050 return NULL;
2051
2052 *found_pages = find_get_pages_range_tag(mapping, index, end,
2053 PAGECACHE_TAG_DIRTY, tofind, wdata->pages);
2054 return wdata;
2055}
2056
2057static unsigned int
2058wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
2059 struct address_space *mapping,
2060 struct writeback_control *wbc,
2061 pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
2062{
2063 unsigned int nr_pages = 0, i;
2064 struct page *page;
2065
2066 for (i = 0; i < found_pages; i++) {
2067 page = wdata->pages[i];
2068
2069
2070
2071
2072
2073
2074
2075 if (nr_pages == 0)
2076 lock_page(page);
2077 else if (!trylock_page(page))
2078 break;
2079
2080 if (unlikely(page->mapping != mapping)) {
2081 unlock_page(page);
2082 break;
2083 }
2084
2085 if (!wbc->range_cyclic && page->index > end) {
2086 *done = true;
2087 unlock_page(page);
2088 break;
2089 }
2090
2091 if (*next && (page->index != *next)) {
2092
2093 unlock_page(page);
2094 break;
2095 }
2096
2097 if (wbc->sync_mode != WB_SYNC_NONE)
2098 wait_on_page_writeback(page);
2099
2100 if (PageWriteback(page) ||
2101 !clear_page_dirty_for_io(page)) {
2102 unlock_page(page);
2103 break;
2104 }
2105
2106
2107
2108
2109
2110 set_page_writeback(page);
2111 if (page_offset(page) >= i_size_read(mapping->host)) {
2112 *done = true;
2113 unlock_page(page);
2114 end_page_writeback(page);
2115 break;
2116 }
2117
2118 wdata->pages[i] = page;
2119 *next = page->index + 1;
2120 ++nr_pages;
2121 }
2122
2123
2124 if (nr_pages == 0)
2125 *index = wdata->pages[0]->index + 1;
2126
2127
2128 for (i = nr_pages; i < found_pages; i++) {
2129 put_page(wdata->pages[i]);
2130 wdata->pages[i] = NULL;
2131 }
2132
2133 return nr_pages;
2134}
2135
2136static int
2137wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2138 struct address_space *mapping, struct writeback_control *wbc)
2139{
2140 int rc;
2141 struct TCP_Server_Info *server =
2142 tlink_tcon(wdata->cfile->tlink)->ses->server;
2143
2144 wdata->sync_mode = wbc->sync_mode;
2145 wdata->nr_pages = nr_pages;
2146 wdata->offset = page_offset(wdata->pages[0]);
2147 wdata->pagesz = PAGE_SIZE;
2148 wdata->tailsz = min(i_size_read(mapping->host) -
2149 page_offset(wdata->pages[nr_pages - 1]),
2150 (loff_t)PAGE_SIZE);
2151 wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2152 wdata->pid = wdata->cfile->pid;
2153
2154 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2155 if (rc)
2156 return rc;
2157
2158 if (wdata->cfile->invalidHandle)
2159 rc = -EAGAIN;
2160 else
2161 rc = server->ops->async_writev(wdata, cifs_writedata_release);
2162
2163 return rc;
2164}
2165
2166static int cifs_writepages(struct address_space *mapping,
2167 struct writeback_control *wbc)
2168{
2169 struct inode *inode = mapping->host;
2170 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2171 struct TCP_Server_Info *server;
2172 bool done = false, scanned = false, range_whole = false;
2173 pgoff_t end, index;
2174 struct cifs_writedata *wdata;
2175 struct cifsFileInfo *cfile = NULL;
2176 int rc = 0;
2177 int saved_rc = 0;
2178 unsigned int xid;
2179
2180
2181
2182
2183
2184 if (cifs_sb->wsize < PAGE_SIZE)
2185 return generic_writepages(mapping, wbc);
2186
2187 xid = get_xid();
2188 if (wbc->range_cyclic) {
2189 index = mapping->writeback_index;
2190 end = -1;
2191 } else {
2192 index = wbc->range_start >> PAGE_SHIFT;
2193 end = wbc->range_end >> PAGE_SHIFT;
2194 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2195 range_whole = true;
2196 scanned = true;
2197 }
2198 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
2199retry:
2200 while (!done && index <= end) {
2201 unsigned int i, nr_pages, found_pages, wsize;
2202 pgoff_t next = 0, tofind, saved_index = index;
2203 struct cifs_credits credits_on_stack;
2204 struct cifs_credits *credits = &credits_on_stack;
2205 int get_file_rc = 0;
2206
2207 if (cfile)
2208 cifsFileInfo_put(cfile);
2209
2210 rc = cifs_get_writable_file(CIFS_I(inode), false, &cfile);
2211
2212
2213 if (rc)
2214 get_file_rc = rc;
2215
2216 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2217 &wsize, credits);
2218 if (rc != 0) {
2219 done = true;
2220 break;
2221 }
2222
2223 tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2224
2225 wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2226 &found_pages);
2227 if (!wdata) {
2228 rc = -ENOMEM;
2229 done = true;
2230 add_credits_and_wake_if(server, credits, 0);
2231 break;
2232 }
2233
2234 if (found_pages == 0) {
2235 kref_put(&wdata->refcount, cifs_writedata_release);
2236 add_credits_and_wake_if(server, credits, 0);
2237 break;
2238 }
2239
2240 nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2241 end, &index, &next, &done);
2242
2243
2244 if (nr_pages == 0) {
2245 kref_put(&wdata->refcount, cifs_writedata_release);
2246 add_credits_and_wake_if(server, credits, 0);
2247 continue;
2248 }
2249
2250 wdata->credits = credits_on_stack;
2251 wdata->cfile = cfile;
2252 cfile = NULL;
2253
2254 if (!wdata->cfile) {
2255 cifs_dbg(VFS, "No writable handle in writepages rc=%d\n",
2256 get_file_rc);
2257 if (is_retryable_error(get_file_rc))
2258 rc = get_file_rc;
2259 else
2260 rc = -EBADF;
2261 } else
2262 rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2263
2264 for (i = 0; i < nr_pages; ++i)
2265 unlock_page(wdata->pages[i]);
2266
2267
2268 if (rc != 0) {
2269 add_credits_and_wake_if(server, &wdata->credits, 0);
2270 for (i = 0; i < nr_pages; ++i) {
2271 if (is_retryable_error(rc))
2272 redirty_page_for_writepage(wbc,
2273 wdata->pages[i]);
2274 else
2275 SetPageError(wdata->pages[i]);
2276 end_page_writeback(wdata->pages[i]);
2277 put_page(wdata->pages[i]);
2278 }
2279 if (!is_retryable_error(rc))
2280 mapping_set_error(mapping, rc);
2281 }
2282 kref_put(&wdata->refcount, cifs_writedata_release);
2283
2284 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2285 index = saved_index;
2286 continue;
2287 }
2288
2289
2290 if (is_interrupt_error(rc)) {
2291 done = true;
2292 break;
2293 }
2294
2295 if (rc != 0 && saved_rc == 0)
2296 saved_rc = rc;
2297
2298 wbc->nr_to_write -= nr_pages;
2299 if (wbc->nr_to_write <= 0)
2300 done = true;
2301
2302 index = next;
2303 }
2304
2305 if (!scanned && !done) {
2306
2307
2308
2309
2310 scanned = true;
2311 index = 0;
2312 goto retry;
2313 }
2314
2315 if (saved_rc != 0)
2316 rc = saved_rc;
2317
2318 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2319 mapping->writeback_index = index;
2320
2321 if (cfile)
2322 cifsFileInfo_put(cfile);
2323 free_xid(xid);
2324 return rc;
2325}
2326
2327static int
2328cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2329{
2330 int rc;
2331 unsigned int xid;
2332
2333 xid = get_xid();
2334
2335 get_page(page);
2336 if (!PageUptodate(page))
2337 cifs_dbg(FYI, "ppw - page not up to date\n");
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349 set_page_writeback(page);
2350retry_write:
2351 rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2352 if (is_retryable_error(rc)) {
2353 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN)
2354 goto retry_write;
2355 redirty_page_for_writepage(wbc, page);
2356 } else if (rc != 0) {
2357 SetPageError(page);
2358 mapping_set_error(page->mapping, rc);
2359 } else {
2360 SetPageUptodate(page);
2361 }
2362 end_page_writeback(page);
2363 put_page(page);
2364 free_xid(xid);
2365 return rc;
2366}
2367
2368static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2369{
2370 int rc = cifs_writepage_locked(page, wbc);
2371 unlock_page(page);
2372 return rc;
2373}
2374
2375static int cifs_write_end(struct file *file, struct address_space *mapping,
2376 loff_t pos, unsigned len, unsigned copied,
2377 struct page *page, void *fsdata)
2378{
2379 int rc;
2380 struct inode *inode = mapping->host;
2381 struct cifsFileInfo *cfile = file->private_data;
2382 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2383 __u32 pid;
2384
2385 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2386 pid = cfile->pid;
2387 else
2388 pid = current->tgid;
2389
2390 cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2391 page, pos, copied);
2392
2393 if (PageChecked(page)) {
2394 if (copied == len)
2395 SetPageUptodate(page);
2396 ClearPageChecked(page);
2397 } else if (!PageUptodate(page) && copied == PAGE_SIZE)
2398 SetPageUptodate(page);
2399
2400 if (!PageUptodate(page)) {
2401 char *page_data;
2402 unsigned offset = pos & (PAGE_SIZE - 1);
2403 unsigned int xid;
2404
2405 xid = get_xid();
2406
2407
2408
2409
2410
2411 page_data = kmap(page);
2412 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2413
2414 kunmap(page);
2415
2416 free_xid(xid);
2417 } else {
2418 rc = copied;
2419 pos += copied;
2420 set_page_dirty(page);
2421 }
2422
2423 if (rc > 0) {
2424 spin_lock(&inode->i_lock);
2425 if (pos > inode->i_size)
2426 i_size_write(inode, pos);
2427 spin_unlock(&inode->i_lock);
2428 }
2429
2430 unlock_page(page);
2431 put_page(page);
2432
2433 return rc;
2434}
2435
2436int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2437 int datasync)
2438{
2439 unsigned int xid;
2440 int rc = 0;
2441 struct cifs_tcon *tcon;
2442 struct TCP_Server_Info *server;
2443 struct cifsFileInfo *smbfile = file->private_data;
2444 struct inode *inode = file_inode(file);
2445 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2446
2447 rc = file_write_and_wait_range(file, start, end);
2448 if (rc)
2449 return rc;
2450
2451 xid = get_xid();
2452
2453 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2454 file, datasync);
2455
2456 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2457 rc = cifs_zap_mapping(inode);
2458 if (rc) {
2459 cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2460 rc = 0;
2461 }
2462 }
2463
2464 tcon = tlink_tcon(smbfile->tlink);
2465 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2466 server = tcon->ses->server;
2467 if (server->ops->flush)
2468 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2469 else
2470 rc = -ENOSYS;
2471 }
2472
2473 free_xid(xid);
2474 return rc;
2475}
2476
2477int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2478{
2479 unsigned int xid;
2480 int rc = 0;
2481 struct cifs_tcon *tcon;
2482 struct TCP_Server_Info *server;
2483 struct cifsFileInfo *smbfile = file->private_data;
2484 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2485
2486 rc = file_write_and_wait_range(file, start, end);
2487 if (rc)
2488 return rc;
2489
2490 xid = get_xid();
2491
2492 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2493 file, datasync);
2494
2495 tcon = tlink_tcon(smbfile->tlink);
2496 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2497 server = tcon->ses->server;
2498 if (server->ops->flush)
2499 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2500 else
2501 rc = -ENOSYS;
2502 }
2503
2504 free_xid(xid);
2505 return rc;
2506}
2507
2508
2509
2510
2511
2512int cifs_flush(struct file *file, fl_owner_t id)
2513{
2514 struct inode *inode = file_inode(file);
2515 int rc = 0;
2516
2517 if (file->f_mode & FMODE_WRITE)
2518 rc = filemap_write_and_wait(inode->i_mapping);
2519
2520 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2521
2522 return rc;
2523}
2524
2525static int
2526cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2527{
2528 int rc = 0;
2529 unsigned long i;
2530
2531 for (i = 0; i < num_pages; i++) {
2532 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2533 if (!pages[i]) {
2534
2535
2536
2537
2538 num_pages = i;
2539 rc = -ENOMEM;
2540 break;
2541 }
2542 }
2543
2544 if (rc) {
2545 for (i = 0; i < num_pages; i++)
2546 put_page(pages[i]);
2547 }
2548 return rc;
2549}
2550
2551static inline
2552size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2553{
2554 size_t num_pages;
2555 size_t clen;
2556
2557 clen = min_t(const size_t, len, wsize);
2558 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2559
2560 if (cur_len)
2561 *cur_len = clen;
2562
2563 return num_pages;
2564}
2565
2566static void
2567cifs_uncached_writedata_release(struct kref *refcount)
2568{
2569 int i;
2570 struct cifs_writedata *wdata = container_of(refcount,
2571 struct cifs_writedata, refcount);
2572
2573 kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
2574 for (i = 0; i < wdata->nr_pages; i++)
2575 put_page(wdata->pages[i]);
2576 cifs_writedata_release(refcount);
2577}
2578
2579static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);
2580
2581static void
2582cifs_uncached_writev_complete(struct work_struct *work)
2583{
2584 struct cifs_writedata *wdata = container_of(work,
2585 struct cifs_writedata, work);
2586 struct inode *inode = d_inode(wdata->cfile->dentry);
2587 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2588
2589 spin_lock(&inode->i_lock);
2590 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2591 if (cifsi->server_eof > inode->i_size)
2592 i_size_write(inode, cifsi->server_eof);
2593 spin_unlock(&inode->i_lock);
2594
2595 complete(&wdata->done);
2596 collect_uncached_write_data(wdata->ctx);
2597
2598 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2599}
2600
2601static int
2602wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2603 size_t *len, unsigned long *num_pages)
2604{
2605 size_t save_len, copied, bytes, cur_len = *len;
2606 unsigned long i, nr_pages = *num_pages;
2607
2608 save_len = cur_len;
2609 for (i = 0; i < nr_pages; i++) {
2610 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2611 copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2612 cur_len -= copied;
2613
2614
2615
2616
2617
2618
2619
2620 if (copied < bytes)
2621 break;
2622 }
2623 cur_len = save_len - cur_len;
2624 *len = cur_len;
2625
2626
2627
2628
2629
2630
2631
2632 if (!cur_len)
2633 return -EFAULT;
2634
2635
2636
2637
2638
2639 *num_pages = i + 1;
2640 return 0;
2641}
2642
2643static int
2644cifs_resend_wdata(struct cifs_writedata *wdata, struct list_head *wdata_list,
2645 struct cifs_aio_ctx *ctx)
2646{
2647 unsigned int wsize;
2648 struct cifs_credits credits;
2649 int rc;
2650 struct TCP_Server_Info *server =
2651 tlink_tcon(wdata->cfile->tlink)->ses->server;
2652
2653 do {
2654 if (wdata->cfile->invalidHandle) {
2655 rc = cifs_reopen_file(wdata->cfile, false);
2656 if (rc == -EAGAIN)
2657 continue;
2658 else if (rc)
2659 break;
2660 }
2661
2662
2663
2664
2665
2666
2667
2668 do {
2669 rc = server->ops->wait_mtu_credits(server, wdata->bytes,
2670 &wsize, &credits);
2671 if (rc)
2672 goto fail;
2673
2674 if (wsize < wdata->bytes) {
2675 add_credits_and_wake_if(server, &credits, 0);
2676 msleep(1000);
2677 }
2678 } while (wsize < wdata->bytes);
2679 wdata->credits = credits;
2680
2681 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2682
2683 if (!rc) {
2684 if (wdata->cfile->invalidHandle)
2685 rc = -EAGAIN;
2686 else
2687 rc = server->ops->async_writev(wdata,
2688 cifs_uncached_writedata_release);
2689 }
2690
2691
2692 if (!rc) {
2693 list_add_tail(&wdata->list, wdata_list);
2694 return 0;
2695 }
2696
2697
2698 add_credits_and_wake_if(server, &wdata->credits, 0);
2699 } while (rc == -EAGAIN);
2700
2701fail:
2702 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2703 return rc;
2704}
2705
2706static int
2707cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2708 struct cifsFileInfo *open_file,
2709 struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
2710 struct cifs_aio_ctx *ctx)
2711{
2712 int rc = 0;
2713 size_t cur_len;
2714 unsigned long nr_pages, num_pages, i;
2715 struct cifs_writedata *wdata;
2716 struct iov_iter saved_from = *from;
2717 loff_t saved_offset = offset;
2718 pid_t pid;
2719 struct TCP_Server_Info *server;
2720 struct page **pagevec;
2721 size_t start;
2722 unsigned int xid;
2723
2724 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2725 pid = open_file->pid;
2726 else
2727 pid = current->tgid;
2728
2729 server = tlink_tcon(open_file->tlink)->ses->server;
2730 xid = get_xid();
2731
2732 do {
2733 unsigned int wsize;
2734 struct cifs_credits credits_on_stack;
2735 struct cifs_credits *credits = &credits_on_stack;
2736
2737 if (open_file->invalidHandle) {
2738 rc = cifs_reopen_file(open_file, false);
2739 if (rc == -EAGAIN)
2740 continue;
2741 else if (rc)
2742 break;
2743 }
2744
2745 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2746 &wsize, credits);
2747 if (rc)
2748 break;
2749
2750 cur_len = min_t(const size_t, len, wsize);
2751
2752 if (ctx->direct_io) {
2753 ssize_t result;
2754
2755 result = iov_iter_get_pages_alloc(
2756 from, &pagevec, cur_len, &start);
2757 if (result < 0) {
2758 cifs_dbg(VFS,
2759 "direct_writev couldn't get user pages "
2760 "(rc=%zd) iter type %d iov_offset %zd "
2761 "count %zd\n",
2762 result, from->type,
2763 from->iov_offset, from->count);
2764 dump_stack();
2765
2766 rc = result;
2767 add_credits_and_wake_if(server, credits, 0);
2768 break;
2769 }
2770 cur_len = (size_t)result;
2771 iov_iter_advance(from, cur_len);
2772
2773 nr_pages =
2774 (cur_len + start + PAGE_SIZE - 1) / PAGE_SIZE;
2775
2776 wdata = cifs_writedata_direct_alloc(pagevec,
2777 cifs_uncached_writev_complete);
2778 if (!wdata) {
2779 rc = -ENOMEM;
2780 add_credits_and_wake_if(server, credits, 0);
2781 break;
2782 }
2783
2784
2785 wdata->page_offset = start;
2786 wdata->tailsz =
2787 nr_pages > 1 ?
2788 cur_len - (PAGE_SIZE - start) -
2789 (nr_pages - 2) * PAGE_SIZE :
2790 cur_len;
2791 } else {
2792 nr_pages = get_numpages(wsize, len, &cur_len);
2793 wdata = cifs_writedata_alloc(nr_pages,
2794 cifs_uncached_writev_complete);
2795 if (!wdata) {
2796 rc = -ENOMEM;
2797 add_credits_and_wake_if(server, credits, 0);
2798 break;
2799 }
2800
2801 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2802 if (rc) {
2803 kvfree(wdata->pages);
2804 kfree(wdata);
2805 add_credits_and_wake_if(server, credits, 0);
2806 break;
2807 }
2808
2809 num_pages = nr_pages;
2810 rc = wdata_fill_from_iovec(
2811 wdata, from, &cur_len, &num_pages);
2812 if (rc) {
2813 for (i = 0; i < nr_pages; i++)
2814 put_page(wdata->pages[i]);
2815 kvfree(wdata->pages);
2816 kfree(wdata);
2817 add_credits_and_wake_if(server, credits, 0);
2818 break;
2819 }
2820
2821
2822
2823
2824
2825 for ( ; nr_pages > num_pages; nr_pages--)
2826 put_page(wdata->pages[nr_pages - 1]);
2827
2828 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2829 }
2830
2831 wdata->sync_mode = WB_SYNC_ALL;
2832 wdata->nr_pages = nr_pages;
2833 wdata->offset = (__u64)offset;
2834 wdata->cfile = cifsFileInfo_get(open_file);
2835 wdata->pid = pid;
2836 wdata->bytes = cur_len;
2837 wdata->pagesz = PAGE_SIZE;
2838 wdata->credits = credits_on_stack;
2839 wdata->ctx = ctx;
2840 kref_get(&ctx->refcount);
2841
2842 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2843
2844 if (!rc) {
2845 if (wdata->cfile->invalidHandle)
2846 rc = -EAGAIN;
2847 else
2848 rc = server->ops->async_writev(wdata,
2849 cifs_uncached_writedata_release);
2850 }
2851
2852 if (rc) {
2853 add_credits_and_wake_if(server, &wdata->credits, 0);
2854 kref_put(&wdata->refcount,
2855 cifs_uncached_writedata_release);
2856 if (rc == -EAGAIN) {
2857 *from = saved_from;
2858 iov_iter_advance(from, offset - saved_offset);
2859 continue;
2860 }
2861 break;
2862 }
2863
2864 list_add_tail(&wdata->list, wdata_list);
2865 offset += cur_len;
2866 len -= cur_len;
2867 } while (len > 0);
2868
2869 free_xid(xid);
2870 return rc;
2871}
2872
2873static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
2874{
2875 struct cifs_writedata *wdata, *tmp;
2876 struct cifs_tcon *tcon;
2877 struct cifs_sb_info *cifs_sb;
2878 struct dentry *dentry = ctx->cfile->dentry;
2879 int rc;
2880
2881 tcon = tlink_tcon(ctx->cfile->tlink);
2882 cifs_sb = CIFS_SB(dentry->d_sb);
2883
2884 mutex_lock(&ctx->aio_mutex);
2885
2886 if (list_empty(&ctx->list)) {
2887 mutex_unlock(&ctx->aio_mutex);
2888 return;
2889 }
2890
2891 rc = ctx->rc;
2892
2893
2894
2895
2896
2897restart_loop:
2898 list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
2899 if (!rc) {
2900 if (!try_wait_for_completion(&wdata->done)) {
2901 mutex_unlock(&ctx->aio_mutex);
2902 return;
2903 }
2904
2905 if (wdata->result)
2906 rc = wdata->result;
2907 else
2908 ctx->total_len += wdata->bytes;
2909
2910
2911 if (rc == -EAGAIN) {
2912 struct list_head tmp_list;
2913 struct iov_iter tmp_from = ctx->iter;
2914
2915 INIT_LIST_HEAD(&tmp_list);
2916 list_del_init(&wdata->list);
2917
2918 if (ctx->direct_io)
2919 rc = cifs_resend_wdata(
2920 wdata, &tmp_list, ctx);
2921 else {
2922 iov_iter_advance(&tmp_from,
2923 wdata->offset - ctx->pos);
2924
2925 rc = cifs_write_from_iter(wdata->offset,
2926 wdata->bytes, &tmp_from,
2927 ctx->cfile, cifs_sb, &tmp_list,
2928 ctx);
2929
2930 kref_put(&wdata->refcount,
2931 cifs_uncached_writedata_release);
2932 }
2933
2934 list_splice(&tmp_list, &ctx->list);
2935 goto restart_loop;
2936 }
2937 }
2938 list_del_init(&wdata->list);
2939 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2940 }
2941
2942 cifs_stats_bytes_written(tcon, ctx->total_len);
2943 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);
2944
2945 ctx->rc = (rc == 0) ? ctx->total_len : rc;
2946
2947 mutex_unlock(&ctx->aio_mutex);
2948
2949 if (ctx->iocb && ctx->iocb->ki_complete)
2950 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
2951 else
2952 complete(&ctx->done);
2953}
2954
2955static ssize_t __cifs_writev(
2956 struct kiocb *iocb, struct iov_iter *from, bool direct)
2957{
2958 struct file *file = iocb->ki_filp;
2959 ssize_t total_written = 0;
2960 struct cifsFileInfo *cfile;
2961 struct cifs_tcon *tcon;
2962 struct cifs_sb_info *cifs_sb;
2963 struct cifs_aio_ctx *ctx;
2964 struct iov_iter saved_from = *from;
2965 size_t len = iov_iter_count(from);
2966 int rc;
2967
2968
2969
2970
2971
2972
2973 if (direct && from->type & ITER_KVEC) {
2974 cifs_dbg(FYI, "use non-direct cifs_writev for kvec I/O\n");
2975 direct = false;
2976 }
2977
2978 rc = generic_write_checks(iocb, from);
2979 if (rc <= 0)
2980 return rc;
2981
2982 cifs_sb = CIFS_FILE_SB(file);
2983 cfile = file->private_data;
2984 tcon = tlink_tcon(cfile->tlink);
2985
2986 if (!tcon->ses->server->ops->async_writev)
2987 return -ENOSYS;
2988
2989 ctx = cifs_aio_ctx_alloc();
2990 if (!ctx)
2991 return -ENOMEM;
2992
2993 ctx->cfile = cifsFileInfo_get(cfile);
2994
2995 if (!is_sync_kiocb(iocb))
2996 ctx->iocb = iocb;
2997
2998 ctx->pos = iocb->ki_pos;
2999
3000 if (direct) {
3001 ctx->direct_io = true;
3002 ctx->iter = *from;
3003 ctx->len = len;
3004 } else {
3005 rc = setup_aio_ctx_iter(ctx, from, WRITE);
3006 if (rc) {
3007 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3008 return rc;
3009 }
3010 }
3011
3012
3013 mutex_lock(&ctx->aio_mutex);
3014
3015 rc = cifs_write_from_iter(iocb->ki_pos, ctx->len, &saved_from,
3016 cfile, cifs_sb, &ctx->list, ctx);
3017
3018
3019
3020
3021
3022
3023
3024 if (!list_empty(&ctx->list))
3025 rc = 0;
3026
3027 mutex_unlock(&ctx->aio_mutex);
3028
3029 if (rc) {
3030 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3031 return rc;
3032 }
3033
3034 if (!is_sync_kiocb(iocb)) {
3035 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3036 return -EIOCBQUEUED;
3037 }
3038
3039 rc = wait_for_completion_killable(&ctx->done);
3040 if (rc) {
3041 mutex_lock(&ctx->aio_mutex);
3042 ctx->rc = rc = -EINTR;
3043 total_written = ctx->total_len;
3044 mutex_unlock(&ctx->aio_mutex);
3045 } else {
3046 rc = ctx->rc;
3047 total_written = ctx->total_len;
3048 }
3049
3050 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3051
3052 if (unlikely(!total_written))
3053 return rc;
3054
3055 iocb->ki_pos += total_written;
3056 return total_written;
3057}
3058
3059ssize_t cifs_direct_writev(struct kiocb *iocb, struct iov_iter *from)
3060{
3061 return __cifs_writev(iocb, from, true);
3062}
3063
3064ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
3065{
3066 return __cifs_writev(iocb, from, false);
3067}
3068
3069static ssize_t
3070cifs_writev(struct kiocb *iocb, struct iov_iter *from)
3071{
3072 struct file *file = iocb->ki_filp;
3073 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
3074 struct inode *inode = file->f_mapping->host;
3075 struct cifsInodeInfo *cinode = CIFS_I(inode);
3076 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
3077 ssize_t rc;
3078
3079 inode_lock(inode);
3080
3081
3082
3083
3084 down_read(&cinode->lock_sem);
3085
3086 rc = generic_write_checks(iocb, from);
3087 if (rc <= 0)
3088 goto out;
3089
3090 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
3091 server->vals->exclusive_lock_type, 0,
3092 NULL, CIFS_WRITE_OP))
3093 rc = __generic_file_write_iter(iocb, from);
3094 else
3095 rc = -EACCES;
3096out:
3097 up_read(&cinode->lock_sem);
3098 inode_unlock(inode);
3099
3100 if (rc > 0)
3101 rc = generic_write_sync(iocb, rc);
3102 return rc;
3103}
3104
3105ssize_t
3106cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
3107{
3108 struct inode *inode = file_inode(iocb->ki_filp);
3109 struct cifsInodeInfo *cinode = CIFS_I(inode);
3110 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3111 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3112 iocb->ki_filp->private_data;
3113 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3114 ssize_t written;
3115
3116 written = cifs_get_writer(cinode);
3117 if (written)
3118 return written;
3119
3120 if (CIFS_CACHE_WRITE(cinode)) {
3121 if (cap_unix(tcon->ses) &&
3122 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
3123 && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
3124 written = generic_file_write_iter(iocb, from);
3125 goto out;
3126 }
3127 written = cifs_writev(iocb, from);
3128 goto out;
3129 }
3130
3131
3132
3133
3134
3135
3136 written = cifs_user_writev(iocb, from);
3137 if (CIFS_CACHE_READ(cinode)) {
3138
3139
3140
3141
3142
3143
3144
3145 cifs_zap_mapping(inode);
3146 cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
3147 inode);
3148 cinode->oplock = 0;
3149 }
3150out:
3151 cifs_put_writer(cinode);
3152 return written;
3153}
3154
3155static struct cifs_readdata *
3156cifs_readdata_direct_alloc(struct page **pages, work_func_t complete)
3157{
3158 struct cifs_readdata *rdata;
3159
3160 rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
3161 if (rdata != NULL) {
3162 rdata->pages = pages;
3163 kref_init(&rdata->refcount);
3164 INIT_LIST_HEAD(&rdata->list);
3165 init_completion(&rdata->done);
3166 INIT_WORK(&rdata->work, complete);
3167 }
3168
3169 return rdata;
3170}
3171
3172static struct cifs_readdata *
3173cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
3174{
3175 struct page **pages =
3176 kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
3177 struct cifs_readdata *ret = NULL;
3178
3179 if (pages) {
3180 ret = cifs_readdata_direct_alloc(pages, complete);
3181 if (!ret)
3182 kfree(pages);
3183 }
3184
3185 return ret;
3186}
3187
3188void
3189cifs_readdata_release(struct kref *refcount)
3190{
3191 struct cifs_readdata *rdata = container_of(refcount,
3192 struct cifs_readdata, refcount);
3193#ifdef CONFIG_CIFS_SMB_DIRECT
3194 if (rdata->mr) {
3195 smbd_deregister_mr(rdata->mr);
3196 rdata->mr = NULL;
3197 }
3198#endif
3199 if (rdata->cfile)
3200 cifsFileInfo_put(rdata->cfile);
3201
3202 kvfree(rdata->pages);
3203 kfree(rdata);
3204}
3205
3206static int
3207cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
3208{
3209 int rc = 0;
3210 struct page *page;
3211 unsigned int i;
3212
3213 for (i = 0; i < nr_pages; i++) {
3214 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
3215 if (!page) {
3216 rc = -ENOMEM;
3217 break;
3218 }
3219 rdata->pages[i] = page;
3220 }
3221
3222 if (rc) {
3223 unsigned int nr_page_failed = i;
3224
3225 for (i = 0; i < nr_page_failed; i++) {
3226 put_page(rdata->pages[i]);
3227 rdata->pages[i] = NULL;
3228 }
3229 }
3230 return rc;
3231}
3232
3233static void
3234cifs_uncached_readdata_release(struct kref *refcount)
3235{
3236 struct cifs_readdata *rdata = container_of(refcount,
3237 struct cifs_readdata, refcount);
3238 unsigned int i;
3239
3240 kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
3241 for (i = 0; i < rdata->nr_pages; i++) {
3242 put_page(rdata->pages[i]);
3243 }
3244 cifs_readdata_release(refcount);
3245}
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256static int
3257cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3258{
3259 size_t remaining = rdata->got_bytes;
3260 unsigned int i;
3261
3262 for (i = 0; i < rdata->nr_pages; i++) {
3263 struct page *page = rdata->pages[i];
3264 size_t copy = min_t(size_t, remaining, PAGE_SIZE);
3265 size_t written;
3266
3267 if (unlikely(iov_iter_is_pipe(iter))) {
3268 void *addr = kmap_atomic(page);
3269
3270 written = copy_to_iter(addr, copy, iter);
3271 kunmap_atomic(addr);
3272 } else
3273 written = copy_page_to_iter(page, 0, copy, iter);
3274 remaining -= written;
3275 if (written < copy && iov_iter_count(iter) > 0)
3276 break;
3277 }
3278 return remaining ? -EFAULT : 0;
3279}
3280
3281static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);
3282
3283static void
3284cifs_uncached_readv_complete(struct work_struct *work)
3285{
3286 struct cifs_readdata *rdata = container_of(work,
3287 struct cifs_readdata, work);
3288
3289 complete(&rdata->done);
3290 collect_uncached_read_data(rdata->ctx);
3291
3292 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3293}
3294
3295static int
3296uncached_fill_pages(struct TCP_Server_Info *server,
3297 struct cifs_readdata *rdata, struct iov_iter *iter,
3298 unsigned int len)
3299{
3300 int result = 0;
3301 unsigned int i;
3302 unsigned int nr_pages = rdata->nr_pages;
3303 unsigned int page_offset = rdata->page_offset;
3304
3305 rdata->got_bytes = 0;
3306 rdata->tailsz = PAGE_SIZE;
3307 for (i = 0; i < nr_pages; i++) {
3308 struct page *page = rdata->pages[i];
3309 size_t n;
3310 unsigned int segment_size = rdata->pagesz;
3311
3312 if (i == 0)
3313 segment_size -= page_offset;
3314 else
3315 page_offset = 0;
3316
3317
3318 if (len <= 0) {
3319
3320 rdata->pages[i] = NULL;
3321 rdata->nr_pages--;
3322 put_page(page);
3323 continue;
3324 }
3325
3326 n = len;
3327 if (len >= segment_size)
3328
3329 n = segment_size;
3330 else
3331 rdata->tailsz = len;
3332 len -= n;
3333
3334 if (iter)
3335 result = copy_page_from_iter(
3336 page, page_offset, n, iter);
3337#ifdef CONFIG_CIFS_SMB_DIRECT
3338 else if (rdata->mr)
3339 result = n;
3340#endif
3341 else
3342 result = cifs_read_page_from_socket(
3343 server, page, page_offset, n);
3344 if (result < 0)
3345 break;
3346
3347 rdata->got_bytes += result;
3348 }
3349
3350 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3351 rdata->got_bytes : result;
3352}
3353
3354static int
3355cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
3356 struct cifs_readdata *rdata, unsigned int len)
3357{
3358 return uncached_fill_pages(server, rdata, NULL, len);
3359}
3360
3361static int
3362cifs_uncached_copy_into_pages(struct TCP_Server_Info *server,
3363 struct cifs_readdata *rdata,
3364 struct iov_iter *iter)
3365{
3366 return uncached_fill_pages(server, rdata, iter, iter->count);
3367}
3368
3369static int cifs_resend_rdata(struct cifs_readdata *rdata,
3370 struct list_head *rdata_list,
3371 struct cifs_aio_ctx *ctx)
3372{
3373 unsigned int rsize;
3374 struct cifs_credits credits;
3375 int rc;
3376 struct TCP_Server_Info *server =
3377 tlink_tcon(rdata->cfile->tlink)->ses->server;
3378
3379 do {
3380 if (rdata->cfile->invalidHandle) {
3381 rc = cifs_reopen_file(rdata->cfile, true);
3382 if (rc == -EAGAIN)
3383 continue;
3384 else if (rc)
3385 break;
3386 }
3387
3388
3389
3390
3391
3392
3393 do {
3394 rc = server->ops->wait_mtu_credits(server, rdata->bytes,
3395 &rsize, &credits);
3396
3397 if (rc)
3398 goto fail;
3399
3400 if (rsize < rdata->bytes) {
3401 add_credits_and_wake_if(server, &credits, 0);
3402 msleep(1000);
3403 }
3404 } while (rsize < rdata->bytes);
3405 rdata->credits = credits;
3406
3407 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3408 if (!rc) {
3409 if (rdata->cfile->invalidHandle)
3410 rc = -EAGAIN;
3411 else
3412 rc = server->ops->async_readv(rdata);
3413 }
3414
3415
3416 if (!rc) {
3417
3418 list_add_tail(&rdata->list, rdata_list);
3419 return 0;
3420 }
3421
3422
3423 add_credits_and_wake_if(server, &rdata->credits, 0);
3424 } while (rc == -EAGAIN);
3425
3426fail:
3427 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3428 return rc;
3429}
3430
3431static int
3432cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3433 struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
3434 struct cifs_aio_ctx *ctx)
3435{
3436 struct cifs_readdata *rdata;
3437 unsigned int npages, rsize;
3438 struct cifs_credits credits_on_stack;
3439 struct cifs_credits *credits = &credits_on_stack;
3440 size_t cur_len;
3441 int rc;
3442 pid_t pid;
3443 struct TCP_Server_Info *server;
3444 struct page **pagevec;
3445 size_t start;
3446 struct iov_iter direct_iov = ctx->iter;
3447
3448 server = tlink_tcon(open_file->tlink)->ses->server;
3449
3450 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3451 pid = open_file->pid;
3452 else
3453 pid = current->tgid;
3454
3455 if (ctx->direct_io)
3456 iov_iter_advance(&direct_iov, offset - ctx->pos);
3457
3458 do {
3459 if (open_file->invalidHandle) {
3460 rc = cifs_reopen_file(open_file, true);
3461 if (rc == -EAGAIN)
3462 continue;
3463 else if (rc)
3464 break;
3465 }
3466
3467 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3468 &rsize, credits);
3469 if (rc)
3470 break;
3471
3472 cur_len = min_t(const size_t, len, rsize);
3473
3474 if (ctx->direct_io) {
3475 ssize_t result;
3476
3477 result = iov_iter_get_pages_alloc(
3478 &direct_iov, &pagevec,
3479 cur_len, &start);
3480 if (result < 0) {
3481 cifs_dbg(VFS,
3482 "couldn't get user pages (rc=%zd)"
3483 " iter type %d"
3484 " iov_offset %zd count %zd\n",
3485 result, direct_iov.type,
3486 direct_iov.iov_offset,
3487 direct_iov.count);
3488 dump_stack();
3489
3490 rc = result;
3491 add_credits_and_wake_if(server, credits, 0);
3492 break;
3493 }
3494 cur_len = (size_t)result;
3495 iov_iter_advance(&direct_iov, cur_len);
3496
3497 rdata = cifs_readdata_direct_alloc(
3498 pagevec, cifs_uncached_readv_complete);
3499 if (!rdata) {
3500 add_credits_and_wake_if(server, credits, 0);
3501 rc = -ENOMEM;
3502 break;
3503 }
3504
3505 npages = (cur_len + start + PAGE_SIZE-1) / PAGE_SIZE;
3506 rdata->page_offset = start;
3507 rdata->tailsz = npages > 1 ?
3508 cur_len-(PAGE_SIZE-start)-(npages-2)*PAGE_SIZE :
3509 cur_len;
3510
3511 } else {
3512
3513 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
3514
3515 rdata = cifs_readdata_alloc(npages,
3516 cifs_uncached_readv_complete);
3517 if (!rdata) {
3518 add_credits_and_wake_if(server, credits, 0);
3519 rc = -ENOMEM;
3520 break;
3521 }
3522
3523 rc = cifs_read_allocate_pages(rdata, npages);
3524 if (rc) {
3525 kvfree(rdata->pages);
3526 kfree(rdata);
3527 add_credits_and_wake_if(server, credits, 0);
3528 break;
3529 }
3530
3531 rdata->tailsz = PAGE_SIZE;
3532 }
3533
3534 rdata->cfile = cifsFileInfo_get(open_file);
3535 rdata->nr_pages = npages;
3536 rdata->offset = offset;
3537 rdata->bytes = cur_len;
3538 rdata->pid = pid;
3539 rdata->pagesz = PAGE_SIZE;
3540 rdata->read_into_pages = cifs_uncached_read_into_pages;
3541 rdata->copy_into_pages = cifs_uncached_copy_into_pages;
3542 rdata->credits = credits_on_stack;
3543 rdata->ctx = ctx;
3544 kref_get(&ctx->refcount);
3545
3546 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3547
3548 if (!rc) {
3549 if (rdata->cfile->invalidHandle)
3550 rc = -EAGAIN;
3551 else
3552 rc = server->ops->async_readv(rdata);
3553 }
3554
3555 if (rc) {
3556 add_credits_and_wake_if(server, &rdata->credits, 0);
3557 kref_put(&rdata->refcount,
3558 cifs_uncached_readdata_release);
3559 if (rc == -EAGAIN) {
3560 iov_iter_revert(&direct_iov, cur_len);
3561 continue;
3562 }
3563 break;
3564 }
3565
3566 list_add_tail(&rdata->list, rdata_list);
3567 offset += cur_len;
3568 len -= cur_len;
3569 } while (len > 0);
3570
3571 return rc;
3572}
3573
3574static void
3575collect_uncached_read_data(struct cifs_aio_ctx *ctx)
3576{
3577 struct cifs_readdata *rdata, *tmp;
3578 struct iov_iter *to = &ctx->iter;
3579 struct cifs_sb_info *cifs_sb;
3580 struct cifs_tcon *tcon;
3581 int rc;
3582
3583 tcon = tlink_tcon(ctx->cfile->tlink);
3584 cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
3585
3586 mutex_lock(&ctx->aio_mutex);
3587
3588 if (list_empty(&ctx->list)) {
3589 mutex_unlock(&ctx->aio_mutex);
3590 return;
3591 }
3592
3593 rc = ctx->rc;
3594
3595again:
3596 list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
3597 if (!rc) {
3598 if (!try_wait_for_completion(&rdata->done)) {
3599 mutex_unlock(&ctx->aio_mutex);
3600 return;
3601 }
3602
3603 if (rdata->result == -EAGAIN) {
3604
3605 struct list_head tmp_list;
3606 unsigned int got_bytes = rdata->got_bytes;
3607
3608 list_del_init(&rdata->list);
3609 INIT_LIST_HEAD(&tmp_list);
3610
3611
3612
3613
3614
3615
3616 if (got_bytes && got_bytes < rdata->bytes) {
3617 rc = 0;
3618 if (!ctx->direct_io)
3619 rc = cifs_readdata_to_iov(rdata, to);
3620 if (rc) {
3621 kref_put(&rdata->refcount,
3622 cifs_uncached_readdata_release);
3623 continue;
3624 }
3625 }
3626
3627 if (ctx->direct_io) {
3628
3629
3630
3631
3632 rc = cifs_resend_rdata(
3633 rdata,
3634 &tmp_list, ctx);
3635 } else {
3636 rc = cifs_send_async_read(
3637 rdata->offset + got_bytes,
3638 rdata->bytes - got_bytes,
3639 rdata->cfile, cifs_sb,
3640 &tmp_list, ctx);
3641
3642 kref_put(&rdata->refcount,
3643 cifs_uncached_readdata_release);
3644 }
3645
3646 list_splice(&tmp_list, &ctx->list);
3647
3648 goto again;
3649 } else if (rdata->result)
3650 rc = rdata->result;
3651 else if (!ctx->direct_io)
3652 rc = cifs_readdata_to_iov(rdata, to);
3653
3654
3655 if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3656 rc = -ENODATA;
3657
3658 ctx->total_len += rdata->got_bytes;
3659 }
3660 list_del_init(&rdata->list);
3661 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3662 }
3663
3664 if (!ctx->direct_io)
3665 ctx->total_len = ctx->len - iov_iter_count(to);
3666
3667
3668 if (rc == -ENODATA)
3669 rc = 0;
3670
3671 ctx->rc = (rc == 0) ? ctx->total_len : rc;
3672
3673 mutex_unlock(&ctx->aio_mutex);
3674
3675 if (ctx->iocb && ctx->iocb->ki_complete)
3676 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
3677 else
3678 complete(&ctx->done);
3679}
3680
3681static ssize_t __cifs_readv(
3682 struct kiocb *iocb, struct iov_iter *to, bool direct)
3683{
3684 size_t len;
3685 struct file *file = iocb->ki_filp;
3686 struct cifs_sb_info *cifs_sb;
3687 struct cifsFileInfo *cfile;
3688 struct cifs_tcon *tcon;
3689 ssize_t rc, total_read = 0;
3690 loff_t offset = iocb->ki_pos;
3691 struct cifs_aio_ctx *ctx;
3692
3693
3694
3695
3696
3697
3698 if (direct && to->type & ITER_KVEC) {
3699 cifs_dbg(FYI, "use non-direct cifs_user_readv for kvec I/O\n");
3700 direct = false;
3701 }
3702
3703 len = iov_iter_count(to);
3704 if (!len)
3705 return 0;
3706
3707 cifs_sb = CIFS_FILE_SB(file);
3708 cfile = file->private_data;
3709 tcon = tlink_tcon(cfile->tlink);
3710
3711 if (!tcon->ses->server->ops->async_readv)
3712 return -ENOSYS;
3713
3714 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3715 cifs_dbg(FYI, "attempting read on write only file instance\n");
3716
3717 ctx = cifs_aio_ctx_alloc();
3718 if (!ctx)
3719 return -ENOMEM;
3720
3721 ctx->cfile = cifsFileInfo_get(cfile);
3722
3723 if (!is_sync_kiocb(iocb))
3724 ctx->iocb = iocb;
3725
3726 if (iter_is_iovec(to))
3727 ctx->should_dirty = true;
3728
3729 if (direct) {
3730 ctx->pos = offset;
3731 ctx->direct_io = true;
3732 ctx->iter = *to;
3733 ctx->len = len;
3734 } else {
3735 rc = setup_aio_ctx_iter(ctx, to, READ);
3736 if (rc) {
3737 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3738 return rc;
3739 }
3740 len = ctx->len;
3741 }
3742
3743
3744 mutex_lock(&ctx->aio_mutex);
3745
3746 rc = cifs_send_async_read(offset, len, cfile, cifs_sb, &ctx->list, ctx);
3747
3748
3749 if (!list_empty(&ctx->list))
3750 rc = 0;
3751
3752 mutex_unlock(&ctx->aio_mutex);
3753
3754 if (rc) {
3755 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3756 return rc;
3757 }
3758
3759 if (!is_sync_kiocb(iocb)) {
3760 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3761 return -EIOCBQUEUED;
3762 }
3763
3764 rc = wait_for_completion_killable(&ctx->done);
3765 if (rc) {
3766 mutex_lock(&ctx->aio_mutex);
3767 ctx->rc = rc = -EINTR;
3768 total_read = ctx->total_len;
3769 mutex_unlock(&ctx->aio_mutex);
3770 } else {
3771 rc = ctx->rc;
3772 total_read = ctx->total_len;
3773 }
3774
3775 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3776
3777 if (total_read) {
3778 iocb->ki_pos += total_read;
3779 return total_read;
3780 }
3781 return rc;
3782}
3783
3784ssize_t cifs_direct_readv(struct kiocb *iocb, struct iov_iter *to)
3785{
3786 return __cifs_readv(iocb, to, true);
3787}
3788
3789ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
3790{
3791 return __cifs_readv(iocb, to, false);
3792}
3793
3794ssize_t
3795cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3796{
3797 struct inode *inode = file_inode(iocb->ki_filp);
3798 struct cifsInodeInfo *cinode = CIFS_I(inode);
3799 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3800 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3801 iocb->ki_filp->private_data;
3802 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3803 int rc = -EACCES;
3804
3805
3806
3807
3808
3809
3810
3811
3812
3813 if (!CIFS_CACHE_READ(cinode))
3814 return cifs_user_readv(iocb, to);
3815
3816 if (cap_unix(tcon->ses) &&
3817 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3818 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
3819 return generic_file_read_iter(iocb, to);
3820
3821
3822
3823
3824
3825 down_read(&cinode->lock_sem);
3826 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3827 tcon->ses->server->vals->shared_lock_type,
3828 0, NULL, CIFS_READ_OP))
3829 rc = generic_file_read_iter(iocb, to);
3830 up_read(&cinode->lock_sem);
3831 return rc;
3832}
3833
3834static ssize_t
3835cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
3836{
3837 int rc = -EACCES;
3838 unsigned int bytes_read = 0;
3839 unsigned int total_read;
3840 unsigned int current_read_size;
3841 unsigned int rsize;
3842 struct cifs_sb_info *cifs_sb;
3843 struct cifs_tcon *tcon;
3844 struct TCP_Server_Info *server;
3845 unsigned int xid;
3846 char *cur_offset;
3847 struct cifsFileInfo *open_file;
3848 struct cifs_io_parms io_parms;
3849 int buf_type = CIFS_NO_BUFFER;
3850 __u32 pid;
3851
3852 xid = get_xid();
3853 cifs_sb = CIFS_FILE_SB(file);
3854
3855
3856 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3857
3858 if (file->private_data == NULL) {
3859 rc = -EBADF;
3860 free_xid(xid);
3861 return rc;
3862 }
3863 open_file = file->private_data;
3864 tcon = tlink_tcon(open_file->tlink);
3865 server = tcon->ses->server;
3866
3867 if (!server->ops->sync_read) {
3868 free_xid(xid);
3869 return -ENOSYS;
3870 }
3871
3872 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3873 pid = open_file->pid;
3874 else
3875 pid = current->tgid;
3876
3877 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3878 cifs_dbg(FYI, "attempting read on write only file instance\n");
3879
3880 for (total_read = 0, cur_offset = read_data; read_size > total_read;
3881 total_read += bytes_read, cur_offset += bytes_read) {
3882 do {
3883 current_read_size = min_t(uint, read_size - total_read,
3884 rsize);
3885
3886
3887
3888
3889
3890 if ((tcon->ses) && !(tcon->ses->capabilities &
3891 tcon->ses->server->vals->cap_large_files)) {
3892 current_read_size = min_t(uint,
3893 current_read_size, CIFSMaxBufSize);
3894 }
3895 if (open_file->invalidHandle) {
3896 rc = cifs_reopen_file(open_file, true);
3897 if (rc != 0)
3898 break;
3899 }
3900 io_parms.pid = pid;
3901 io_parms.tcon = tcon;
3902 io_parms.offset = *offset;
3903 io_parms.length = current_read_size;
3904 rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3905 &bytes_read, &cur_offset,
3906 &buf_type);
3907 } while (rc == -EAGAIN);
3908
3909 if (rc || (bytes_read == 0)) {
3910 if (total_read) {
3911 break;
3912 } else {
3913 free_xid(xid);
3914 return rc;
3915 }
3916 } else {
3917 cifs_stats_bytes_read(tcon, total_read);
3918 *offset += bytes_read;
3919 }
3920 }
3921 free_xid(xid);
3922 return total_read;
3923}
3924
3925
3926
3927
3928
3929static vm_fault_t
3930cifs_page_mkwrite(struct vm_fault *vmf)
3931{
3932 struct page *page = vmf->page;
3933
3934 lock_page(page);
3935 return VM_FAULT_LOCKED;
3936}
3937
3938static const struct vm_operations_struct cifs_file_vm_ops = {
3939 .fault = filemap_fault,
3940 .map_pages = filemap_map_pages,
3941 .page_mkwrite = cifs_page_mkwrite,
3942};
3943
3944int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3945{
3946 int xid, rc = 0;
3947 struct inode *inode = file_inode(file);
3948
3949 xid = get_xid();
3950
3951 if (!CIFS_CACHE_READ(CIFS_I(inode)))
3952 rc = cifs_zap_mapping(inode);
3953 if (!rc)
3954 rc = generic_file_mmap(file, vma);
3955 if (!rc)
3956 vma->vm_ops = &cifs_file_vm_ops;
3957
3958 free_xid(xid);
3959 return rc;
3960}
3961
3962int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3963{
3964 int rc, xid;
3965
3966 xid = get_xid();
3967
3968 rc = cifs_revalidate_file(file);
3969 if (rc)
3970 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3971 rc);
3972 if (!rc)
3973 rc = generic_file_mmap(file, vma);
3974 if (!rc)
3975 vma->vm_ops = &cifs_file_vm_ops;
3976
3977 free_xid(xid);
3978 return rc;
3979}
3980
3981static void
3982cifs_readv_complete(struct work_struct *work)
3983{
3984 unsigned int i, got_bytes;
3985 struct cifs_readdata *rdata = container_of(work,
3986 struct cifs_readdata, work);
3987
3988 got_bytes = rdata->got_bytes;
3989 for (i = 0; i < rdata->nr_pages; i++) {
3990 struct page *page = rdata->pages[i];
3991
3992 lru_cache_add_file(page);
3993
3994 if (rdata->result == 0 ||
3995 (rdata->result == -EAGAIN && got_bytes)) {
3996 flush_dcache_page(page);
3997 SetPageUptodate(page);
3998 }
3999
4000 unlock_page(page);
4001
4002 if (rdata->result == 0 ||
4003 (rdata->result == -EAGAIN && got_bytes))
4004 cifs_readpage_to_fscache(rdata->mapping->host, page);
4005
4006 got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
4007
4008 put_page(page);
4009 rdata->pages[i] = NULL;
4010 }
4011 kref_put(&rdata->refcount, cifs_readdata_release);
4012}
4013
4014static int
4015readpages_fill_pages(struct TCP_Server_Info *server,
4016 struct cifs_readdata *rdata, struct iov_iter *iter,
4017 unsigned int len)
4018{
4019 int result = 0;
4020 unsigned int i;
4021 u64 eof;
4022 pgoff_t eof_index;
4023 unsigned int nr_pages = rdata->nr_pages;
4024 unsigned int page_offset = rdata->page_offset;
4025
4026
4027 eof = CIFS_I(rdata->mapping->host)->server_eof;
4028 eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
4029 cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
4030
4031 rdata->got_bytes = 0;
4032 rdata->tailsz = PAGE_SIZE;
4033 for (i = 0; i < nr_pages; i++) {
4034 struct page *page = rdata->pages[i];
4035 unsigned int to_read = rdata->pagesz;
4036 size_t n;
4037
4038 if (i == 0)
4039 to_read -= page_offset;
4040 else
4041 page_offset = 0;
4042
4043 n = to_read;
4044
4045 if (len >= to_read) {
4046 len -= to_read;
4047 } else if (len > 0) {
4048
4049 zero_user(page, len + page_offset, to_read - len);
4050 n = rdata->tailsz = len;
4051 len = 0;
4052 } else if (page->index > eof_index) {
4053
4054
4055
4056
4057
4058
4059
4060
4061 zero_user(page, 0, PAGE_SIZE);
4062 lru_cache_add_file(page);
4063 flush_dcache_page(page);
4064 SetPageUptodate(page);
4065 unlock_page(page);
4066 put_page(page);
4067 rdata->pages[i] = NULL;
4068 rdata->nr_pages--;
4069 continue;
4070 } else {
4071
4072 lru_cache_add_file(page);
4073 unlock_page(page);
4074 put_page(page);
4075 rdata->pages[i] = NULL;
4076 rdata->nr_pages--;
4077 continue;
4078 }
4079
4080 if (iter)
4081 result = copy_page_from_iter(
4082 page, page_offset, n, iter);
4083#ifdef CONFIG_CIFS_SMB_DIRECT
4084 else if (rdata->mr)
4085 result = n;
4086#endif
4087 else
4088 result = cifs_read_page_from_socket(
4089 server, page, page_offset, n);
4090 if (result < 0)
4091 break;
4092
4093 rdata->got_bytes += result;
4094 }
4095
4096 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
4097 rdata->got_bytes : result;
4098}
4099
4100static int
4101cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
4102 struct cifs_readdata *rdata, unsigned int len)
4103{
4104 return readpages_fill_pages(server, rdata, NULL, len);
4105}
4106
4107static int
4108cifs_readpages_copy_into_pages(struct TCP_Server_Info *server,
4109 struct cifs_readdata *rdata,
4110 struct iov_iter *iter)
4111{
4112 return readpages_fill_pages(server, rdata, iter, iter->count);
4113}
4114
4115static int
4116readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
4117 unsigned int rsize, struct list_head *tmplist,
4118 unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
4119{
4120 struct page *page, *tpage;
4121 unsigned int expected_index;
4122 int rc;
4123 gfp_t gfp = readahead_gfp_mask(mapping);
4124
4125 INIT_LIST_HEAD(tmplist);
4126
4127 page = lru_to_page(page_list);
4128
4129
4130
4131
4132
4133
4134 __SetPageLocked(page);
4135 rc = add_to_page_cache_locked(page, mapping,
4136 page->index, gfp);
4137
4138
4139 if (rc) {
4140 __ClearPageLocked(page);
4141 return rc;
4142 }
4143
4144
4145 *offset = (loff_t)page->index << PAGE_SHIFT;
4146 *bytes = PAGE_SIZE;
4147 *nr_pages = 1;
4148 list_move_tail(&page->lru, tmplist);
4149
4150
4151 expected_index = page->index + 1;
4152 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
4153
4154 if (page->index != expected_index)
4155 break;
4156
4157
4158 if (*bytes + PAGE_SIZE > rsize)
4159 break;
4160
4161 __SetPageLocked(page);
4162 if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
4163 __ClearPageLocked(page);
4164 break;
4165 }
4166 list_move_tail(&page->lru, tmplist);
4167 (*bytes) += PAGE_SIZE;
4168 expected_index++;
4169 (*nr_pages)++;
4170 }
4171 return rc;
4172}
4173
4174static int cifs_readpages(struct file *file, struct address_space *mapping,
4175 struct list_head *page_list, unsigned num_pages)
4176{
4177 int rc;
4178 struct list_head tmplist;
4179 struct cifsFileInfo *open_file = file->private_data;
4180 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
4181 struct TCP_Server_Info *server;
4182 pid_t pid;
4183 unsigned int xid;
4184
4185 xid = get_xid();
4186
4187
4188
4189
4190
4191
4192
4193 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
4194 &num_pages);
4195 if (rc == 0) {
4196 free_xid(xid);
4197 return rc;
4198 }
4199
4200 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4201 pid = open_file->pid;
4202 else
4203 pid = current->tgid;
4204
4205 rc = 0;
4206 server = tlink_tcon(open_file->tlink)->ses->server;
4207
4208 cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
4209 __func__, file, mapping, num_pages);
4210
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220
4221
4222 while (!list_empty(page_list)) {
4223 unsigned int i, nr_pages, bytes, rsize;
4224 loff_t offset;
4225 struct page *page, *tpage;
4226 struct cifs_readdata *rdata;
4227 struct cifs_credits credits_on_stack;
4228 struct cifs_credits *credits = &credits_on_stack;
4229
4230 if (open_file->invalidHandle) {
4231 rc = cifs_reopen_file(open_file, true);
4232 if (rc == -EAGAIN)
4233 continue;
4234 else if (rc)
4235 break;
4236 }
4237
4238 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
4239 &rsize, credits);
4240 if (rc)
4241 break;
4242
4243
4244
4245
4246
4247
4248
4249 if (unlikely(rsize < PAGE_SIZE)) {
4250 add_credits_and_wake_if(server, credits, 0);
4251 free_xid(xid);
4252 return 0;
4253 }
4254
4255 rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
4256 &nr_pages, &offset, &bytes);
4257 if (rc) {
4258 add_credits_and_wake_if(server, credits, 0);
4259 break;
4260 }
4261
4262 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
4263 if (!rdata) {
4264
4265 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4266 list_del(&page->lru);
4267 lru_cache_add_file(page);
4268 unlock_page(page);
4269 put_page(page);
4270 }
4271 rc = -ENOMEM;
4272 add_credits_and_wake_if(server, credits, 0);
4273 break;
4274 }
4275
4276 rdata->cfile = cifsFileInfo_get(open_file);
4277 rdata->mapping = mapping;
4278 rdata->offset = offset;
4279 rdata->bytes = bytes;
4280 rdata->pid = pid;
4281 rdata->pagesz = PAGE_SIZE;
4282 rdata->tailsz = PAGE_SIZE;
4283 rdata->read_into_pages = cifs_readpages_read_into_pages;
4284 rdata->copy_into_pages = cifs_readpages_copy_into_pages;
4285 rdata->credits = credits_on_stack;
4286
4287 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4288 list_del(&page->lru);
4289 rdata->pages[rdata->nr_pages++] = page;
4290 }
4291
4292 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4293
4294 if (!rc) {
4295 if (rdata->cfile->invalidHandle)
4296 rc = -EAGAIN;
4297 else
4298 rc = server->ops->async_readv(rdata);
4299 }
4300
4301 if (rc) {
4302 add_credits_and_wake_if(server, &rdata->credits, 0);
4303 for (i = 0; i < rdata->nr_pages; i++) {
4304 page = rdata->pages[i];
4305 lru_cache_add_file(page);
4306 unlock_page(page);
4307 put_page(page);
4308 }
4309
4310 kref_put(&rdata->refcount, cifs_readdata_release);
4311 break;
4312 }
4313
4314 kref_put(&rdata->refcount, cifs_readdata_release);
4315 }
4316
4317
4318
4319
4320
4321 cifs_fscache_readpages_cancel(mapping->host, page_list);
4322 free_xid(xid);
4323 return rc;
4324}
4325
4326
4327
4328
4329static int cifs_readpage_worker(struct file *file, struct page *page,
4330 loff_t *poffset)
4331{
4332 char *read_data;
4333 int rc;
4334
4335
4336 rc = cifs_readpage_from_fscache(file_inode(file), page);
4337 if (rc == 0)
4338 goto read_complete;
4339
4340 read_data = kmap(page);
4341
4342
4343 rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
4344
4345 if (rc < 0)
4346 goto io_error;
4347 else
4348 cifs_dbg(FYI, "Bytes read %d\n", rc);
4349
4350
4351 file_inode(file)->i_atime = current_time(file_inode(file));
4352 if (timespec64_compare(&(file_inode(file)->i_atime), &(file_inode(file)->i_mtime)))
4353 file_inode(file)->i_atime = file_inode(file)->i_mtime;
4354 else
4355 file_inode(file)->i_atime = current_time(file_inode(file));
4356
4357 if (PAGE_SIZE > rc)
4358 memset(read_data + rc, 0, PAGE_SIZE - rc);
4359
4360 flush_dcache_page(page);
4361 SetPageUptodate(page);
4362
4363
4364 cifs_readpage_to_fscache(file_inode(file), page);
4365
4366 rc = 0;
4367
4368io_error:
4369 kunmap(page);
4370 unlock_page(page);
4371
4372read_complete:
4373 return rc;
4374}
4375
4376static int cifs_readpage(struct file *file, struct page *page)
4377{
4378 loff_t offset = (loff_t)page->index << PAGE_SHIFT;
4379 int rc = -EACCES;
4380 unsigned int xid;
4381
4382 xid = get_xid();
4383
4384 if (file->private_data == NULL) {
4385 rc = -EBADF;
4386 free_xid(xid);
4387 return rc;
4388 }
4389
4390 cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
4391 page, (int)offset, (int)offset);
4392
4393 rc = cifs_readpage_worker(file, page, &offset);
4394
4395 free_xid(xid);
4396 return rc;
4397}
4398
4399static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
4400{
4401 struct cifsFileInfo *open_file;
4402 struct cifs_tcon *tcon =
4403 cifs_sb_master_tcon(CIFS_SB(cifs_inode->vfs_inode.i_sb));
4404
4405 spin_lock(&tcon->open_file_lock);
4406 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
4407 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
4408 spin_unlock(&tcon->open_file_lock);
4409 return 1;
4410 }
4411 }
4412 spin_unlock(&tcon->open_file_lock);
4413 return 0;
4414}
4415
4416
4417
4418
4419
4420
4421
4422bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
4423{
4424 if (!cifsInode)
4425 return true;
4426
4427 if (is_inode_writable(cifsInode)) {
4428
4429 struct cifs_sb_info *cifs_sb;
4430
4431 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
4432 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
4433
4434
4435 return true;
4436 }
4437
4438 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
4439 return true;
4440
4441 return false;
4442 } else
4443 return true;
4444}
4445
4446static int cifs_write_begin(struct file *file, struct address_space *mapping,
4447 loff_t pos, unsigned len, unsigned flags,
4448 struct page **pagep, void **fsdata)
4449{
4450 int oncethru = 0;
4451 pgoff_t index = pos >> PAGE_SHIFT;
4452 loff_t offset = pos & (PAGE_SIZE - 1);
4453 loff_t page_start = pos & PAGE_MASK;
4454 loff_t i_size;
4455 struct page *page;
4456 int rc = 0;
4457
4458 cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
4459
4460start:
4461 page = grab_cache_page_write_begin(mapping, index, flags);
4462 if (!page) {
4463 rc = -ENOMEM;
4464 goto out;
4465 }
4466
4467 if (PageUptodate(page))
4468 goto out;
4469
4470
4471
4472
4473
4474
4475 if (len == PAGE_SIZE)
4476 goto out;
4477
4478
4479
4480
4481
4482
4483
4484 if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
4485 i_size = i_size_read(mapping->host);
4486 if (page_start >= i_size ||
4487 (offset == 0 && (pos + len) >= i_size)) {
4488 zero_user_segments(page, 0, offset,
4489 offset + len,
4490 PAGE_SIZE);
4491
4492
4493
4494
4495
4496
4497 SetPageChecked(page);
4498 goto out;
4499 }
4500 }
4501
4502 if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
4503
4504
4505
4506
4507
4508 cifs_readpage_worker(file, page, &page_start);
4509 put_page(page);
4510 oncethru = 1;
4511 goto start;
4512 } else {
4513
4514
4515
4516
4517 }
4518out:
4519 *pagep = page;
4520 return rc;
4521}
4522
4523static int cifs_release_page(struct page *page, gfp_t gfp)
4524{
4525 if (PagePrivate(page))
4526 return 0;
4527
4528 return cifs_fscache_release_page(page, gfp);
4529}
4530
4531static void cifs_invalidate_page(struct page *page, unsigned int offset,
4532 unsigned int length)
4533{
4534 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
4535
4536 if (offset == 0 && length == PAGE_SIZE)
4537 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
4538}
4539
4540static int cifs_launder_page(struct page *page)
4541{
4542 int rc = 0;
4543 loff_t range_start = page_offset(page);
4544 loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
4545 struct writeback_control wbc = {
4546 .sync_mode = WB_SYNC_ALL,
4547 .nr_to_write = 0,
4548 .range_start = range_start,
4549 .range_end = range_end,
4550 };
4551
4552 cifs_dbg(FYI, "Launder page: %p\n", page);
4553
4554 if (clear_page_dirty_for_io(page))
4555 rc = cifs_writepage_locked(page, &wbc);
4556
4557 cifs_fscache_invalidate_page(page, page->mapping->host);
4558 return rc;
4559}
4560
4561void cifs_oplock_break(struct work_struct *work)
4562{
4563 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
4564 oplock_break);
4565 struct inode *inode = d_inode(cfile->dentry);
4566 struct cifsInodeInfo *cinode = CIFS_I(inode);
4567 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4568 struct TCP_Server_Info *server = tcon->ses->server;
4569 int rc = 0;
4570
4571 wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
4572 TASK_UNINTERRUPTIBLE);
4573
4574 server->ops->downgrade_oplock(server, cinode,
4575 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, &cinode->flags));
4576
4577 if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
4578 cifs_has_mand_locks(cinode)) {
4579 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
4580 inode);
4581 cinode->oplock = 0;
4582 }
4583
4584 if (inode && S_ISREG(inode->i_mode)) {
4585 if (CIFS_CACHE_READ(cinode))
4586 break_lease(inode, O_RDONLY);
4587 else
4588 break_lease(inode, O_WRONLY);
4589 rc = filemap_fdatawrite(inode->i_mapping);
4590 if (!CIFS_CACHE_READ(cinode)) {
4591 rc = filemap_fdatawait(inode->i_mapping);
4592 mapping_set_error(inode->i_mapping, rc);
4593 cifs_zap_mapping(inode);
4594 }
4595 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
4596 }
4597
4598 rc = cifs_push_locks(cfile);
4599 if (rc)
4600 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
4601
4602
4603
4604
4605
4606
4607
4608 if (!cfile->oplock_break_cancelled) {
4609 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
4610 cinode);
4611 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
4612 }
4613 _cifsFileInfo_put(cfile, false );
4614 cifs_done_oplock_break(cinode);
4615}
4616
4617
4618
4619
4620
4621
4622
4623
4624
4625
4626static ssize_t
4627cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
4628{
4629
4630
4631
4632
4633 return -EINVAL;
4634}
4635
4636
4637const struct address_space_operations cifs_addr_ops = {
4638 .readpage = cifs_readpage,
4639 .readpages = cifs_readpages,
4640 .writepage = cifs_writepage,
4641 .writepages = cifs_writepages,
4642 .write_begin = cifs_write_begin,
4643 .write_end = cifs_write_end,
4644 .set_page_dirty = __set_page_dirty_nobuffers,
4645 .releasepage = cifs_release_page,
4646 .direct_IO = cifs_direct_io,
4647 .invalidatepage = cifs_invalidate_page,
4648 .launder_page = cifs_launder_page,
4649};
4650
4651
4652
4653
4654
4655
4656const struct address_space_operations cifs_addr_ops_smallbuf = {
4657 .readpage = cifs_readpage,
4658 .writepage = cifs_writepage,
4659 .writepages = cifs_writepages,
4660 .write_begin = cifs_write_begin,
4661 .write_end = cifs_write_end,
4662 .set_page_dirty = __set_page_dirty_nobuffers,
4663 .releasepage = cifs_release_page,
4664 .invalidatepage = cifs_invalidate_page,
4665 .launder_page = cifs_launder_page,
4666};
4667