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