1 // SPDX-License-Identifier: LGPL-2.1 1
2 /*
3 *
4 * vfs operations that deal with files
5 *
6 * Copyright (C) International Business Mach
7 * Author(s): Steve French (sfrench@us.ibm.c
8 * Jeremy Allison (jra@samba.org)
9 *
10 */
11 #include <linux/fs.h>
12 #include <linux/filelock.h>
13 #include <linux/backing-dev.h>
14 #include <linux/stat.h>
15 #include <linux/fcntl.h>
16 #include <linux/pagemap.h>
17 #include <linux/pagevec.h>
18 #include <linux/writeback.h>
19 #include <linux/task_io_accounting_ops.h>
20 #include <linux/delay.h>
21 #include <linux/mount.h>
22 #include <linux/slab.h>
23 #include <linux/swap.h>
24 #include <linux/mm.h>
25 #include <asm/div64.h>
26 #include "cifsfs.h"
27 #include "cifspdu.h"
28 #include "cifsglob.h"
29 #include "cifsproto.h"
30 #include "smb2proto.h"
31 #include "cifs_unicode.h"
32 #include "cifs_debug.h"
33 #include "cifs_fs_sb.h"
34 #include "fscache.h"
35 #include "smbdirect.h"
36 #include "fs_context.h"
37 #include "cifs_ioctl.h"
38 #include "cached_dir.h"
39 #include <trace/events/netfs.h>
40
41 static int cifs_reopen_file(struct cifsFileInf
42
43 /*
44 * Prepare a subrequest to upload to the serve
45 * so that we know the maximum amount of data
46 */
47 static void cifs_prepare_write(struct netfs_io
48 {
49 struct cifs_io_subrequest *wdata =
50 container_of(subreq, struct ci
51 struct cifs_io_request *req = wdata->r
52 struct netfs_io_stream *stream = &req-
53 struct TCP_Server_Info *server;
54 struct cifsFileInfo *open_file = req->
55 size_t wsize = req->rreq.wsize;
56 int rc;
57
58 if (!wdata->have_xid) {
59 wdata->xid = get_xid();
60 wdata->have_xid = true;
61 }
62
63 server = cifs_pick_channel(tlink_tcon(
64 wdata->server = server;
65
66 retry:
67 if (open_file->invalidHandle) {
68 rc = cifs_reopen_file(open_fil
69 if (rc < 0) {
70 if (rc == -EAGAIN)
71 goto retry;
72 subreq->error = rc;
73 return netfs_prepare_w
74 }
75 }
76
77 rc = server->ops->wait_mtu_credits(ser
78 &wd
79 if (rc < 0) {
80 subreq->error = rc;
81 return netfs_prepare_write_fai
82 }
83
84 wdata->credits.rreq_debug_id = subreq-
85 wdata->credits.rreq_debug_index = subr
86 wdata->credits.in_flight_check = 1;
87 trace_smb3_rw_credits(wdata->rreq->deb
88 wdata->subreq.de
89 wdata->credits.v
90 server->credits,
91 wdata->credits.v
92 cifs_trace_rw_cr
93
94 #ifdef CONFIG_CIFS_SMB_DIRECT
95 if (server->smbd_conn)
96 stream->sreq_max_segs = server
97 #endif
98 }
99
100 /*
101 * Issue a subrequest to upload to the server.
102 */
103 static void cifs_issue_write(struct netfs_io_s
104 {
105 struct cifs_io_subrequest *wdata =
106 container_of(subreq, struct ci
107 struct cifs_sb_info *sbi = CIFS_SB(sub
108 int rc;
109
110 if (cifs_forced_shutdown(sbi)) {
111 rc = -EIO;
112 goto fail;
113 }
114
115 rc = adjust_credits(wdata->server, wda
116 if (rc)
117 goto fail;
118
119 rc = -EAGAIN;
120 if (wdata->req->cfile->invalidHandle)
121 goto fail;
122
123 wdata->server->ops->async_writev(wdata
124 out:
125 return;
126
127 fail:
128 if (rc == -EAGAIN)
129 trace_netfs_sreq(subreq, netfs
130 else
131 trace_netfs_sreq(subreq, netfs
132 add_credits_and_wake_if(wdata->server,
133 cifs_write_subrequest_terminated(wdata
134 goto out;
135 }
136
137 static void cifs_netfs_invalidate_cache(struct
138 {
139 cifs_invalidate_cache(wreq->inode, 0);
140 }
141
142 /*
143 * Negotiate the size of a read operation on b
144 */
145 static int cifs_prepare_read(struct netfs_io_s
146 {
147 struct netfs_io_request *rreq = subreq
148 struct cifs_io_subrequest *rdata = con
149 struct cifs_io_request *req = containe
150 struct TCP_Server_Info *server = req->
151 struct cifs_sb_info *cifs_sb = CIFS_SB
152 size_t size;
153 int rc = 0;
154
155 if (!rdata->have_xid) {
156 rdata->xid = get_xid();
157 rdata->have_xid = true;
158 }
159 rdata->server = server;
160
161 if (cifs_sb->ctx->rsize == 0)
162 cifs_sb->ctx->rsize =
163 server->ops->negotiate
164
165
166 rc = server->ops->wait_mtu_credits(ser
167 &si
168 if (rc)
169 return rc;
170
171 rreq->io_streams[0].sreq_max_len = siz
172
173 rdata->credits.in_flight_check = 1;
174 rdata->credits.rreq_debug_id = rreq->d
175 rdata->credits.rreq_debug_index = subr
176
177 trace_smb3_rw_credits(rdata->rreq->deb
178 rdata->subreq.de
179 rdata->credits.v
180 server->credits,
181 cifs_trace_rw_cr
182
183 #ifdef CONFIG_CIFS_SMB_DIRECT
184 if (server->smbd_conn)
185 rreq->io_streams[0].sreq_max_s
186 #endif
187 return 0;
188 }
189
190 /*
191 * Issue a read operation on behalf of the net
192 * to make a read of a certain size at a point
193 * to only read a portion of that, but as long
194 * helper will call us again so that we can is
195 */
196 static void cifs_issue_read(struct netfs_io_su
197 {
198 struct netfs_io_request *rreq = subreq
199 struct cifs_io_subrequest *rdata = con
200 struct cifs_io_request *req = containe
201 struct TCP_Server_Info *server = req->
202 int rc = 0;
203
204 cifs_dbg(FYI, "%s: op=%08x[%x] mapping
205 __func__, rreq->debug_id, sub
206 subreq->transferred, subreq->
207
208 rc = adjust_credits(server, rdata, cif
209 if (rc)
210 goto failed;
211
212 if (req->cfile->invalidHandle) {
213 do {
214 rc = cifs_reopen_file(
215 } while (rc == -EAGAIN);
216 if (rc)
217 goto failed;
218 }
219
220 if (subreq->rreq->origin != NETFS_DIO_
221 __set_bit(NETFS_SREQ_CLEAR_TAI
222
223 trace_netfs_sreq(subreq, netfs_sreq_tr
224 rc = rdata->server->ops->async_readv(r
225 if (rc)
226 goto failed;
227 return;
228
229 failed:
230 netfs_read_subreq_terminated(subreq, r
231 }
232
233 /*
234 * Writeback calls this when it finds a folio
235 * called if writeback only has copy-to-cache
236 */
237 static void cifs_begin_writeback(struct netfs_
238 {
239 struct cifs_io_request *req = containe
240 int ret;
241
242 ret = cifs_get_writable_file(CIFS_I(wr
243 if (ret) {
244 cifs_dbg(VFS, "No writable han
245 return;
246 }
247
248 wreq->io_streams[0].avail = true;
249 }
250
251 /*
252 * Initialise a request.
253 */
254 static int cifs_init_request(struct netfs_io_r
255 {
256 struct cifs_io_request *req = containe
257 struct cifs_sb_info *cifs_sb = CIFS_SB
258 struct cifsFileInfo *open_file = NULL;
259
260 rreq->rsize = cifs_sb->ctx->rsize;
261 rreq->wsize = cifs_sb->ctx->wsize;
262 req->pid = current->tgid; // Ummm...
263
264 if (file) {
265 open_file = file->private_data
266 rreq->netfs_priv = file->priva
267 req->cfile = cifsFileInfo_get(
268 req->server = cifs_pick_channe
269 if (cifs_sb->mnt_cifs_flags &
270 req->pid = req->cfile-
271 } else if (rreq->origin != NETFS_WRITE
272 WARN_ON_ONCE(1);
273 return -EIO;
274 }
275
276 return 0;
277 }
278
279 /*
280 * Completion of a request operation.
281 */
282 static void cifs_rreq_done(struct netfs_io_req
283 {
284 struct timespec64 atime, mtime;
285 struct inode *inode = rreq->inode;
286
287 /* we do not want atime to be less tha
288 atime = inode_set_atime_to_ts(inode, c
289 mtime = inode_get_mtime(inode);
290 if (timespec64_compare(&atime, &mtime)
291 inode_set_atime_to_ts(inode, i
292 }
293
294 static void cifs_free_request(struct netfs_io_
295 {
296 struct cifs_io_request *req = containe
297
298 if (req->cfile)
299 cifsFileInfo_put(req->cfile);
300 }
301
302 static void cifs_free_subrequest(struct netfs_
303 {
304 struct cifs_io_subrequest *rdata =
305 container_of(subreq, struct ci
306 int rc = subreq->error;
307
308 if (rdata->subreq.source == NETFS_DOWN
309 #ifdef CONFIG_CIFS_SMB_DIRECT
310 if (rdata->mr) {
311 smbd_deregister_mr(rda
312 rdata->mr = NULL;
313 }
314 #endif
315 }
316
317 if (rdata->credits.value != 0) {
318 trace_smb3_rw_credits(rdata->r
319 rdata->s
320 rdata->c
321 rdata->s
322 rdata->s
323 -rdata->
324 cifs_tra
325 if (rdata->server)
326 add_credits_and_wake_i
327 else
328 rdata->credits.value =
329 }
330
331 if (rdata->have_xid)
332 free_xid(rdata->xid);
333 }
334
335 const struct netfs_request_ops cifs_req_ops =
336 .request_pool = &cifs_io_req
337 .subrequest_pool = &cifs_io_sub
338 .init_request = cifs_init_re
339 .free_request = cifs_free_re
340 .free_subrequest = cifs_free_su
341 .prepare_read = cifs_prepare
342 .issue_read = cifs_issue_r
343 .done = cifs_rreq_do
344 .begin_writeback = cifs_begin_w
345 .prepare_write = cifs_prepare
346 .issue_write = cifs_issue_w
347 .invalidate_cache = cifs_netfs_i
348 };
349
350 /*
351 * Mark as invalid, all open files on tree con
352 * were closed when session to server was lost
353 */
354 void
355 cifs_mark_open_files_invalid(struct cifs_tcon
356 {
357 struct cifsFileInfo *open_file = NULL;
358 struct list_head *tmp;
359 struct list_head *tmp1;
360
361 /* only send once per connect */
362 spin_lock(&tcon->tc_lock);
363 if (tcon->need_reconnect)
364 tcon->status = TID_NEED_RECON;
365
366 if (tcon->status != TID_NEED_RECON) {
367 spin_unlock(&tcon->tc_lock);
368 return;
369 }
370 tcon->status = TID_IN_FILES_INVALIDATE
371 spin_unlock(&tcon->tc_lock);
372
373 /* list all files open on tree connect
374 spin_lock(&tcon->open_file_lock);
375 list_for_each_safe(tmp, tmp1, &tcon->o
376 open_file = list_entry(tmp, st
377 open_file->invalidHandle = tru
378 open_file->oplock_break_cancel
379 }
380 spin_unlock(&tcon->open_file_lock);
381
382 invalidate_all_cached_dirs(tcon);
383 spin_lock(&tcon->tc_lock);
384 if (tcon->status == TID_IN_FILES_INVAL
385 tcon->status = TID_NEED_TCON;
386 spin_unlock(&tcon->tc_lock);
387
388 /*
389 * BB Add call to invalidate_inodes(sb
390 * to this tcon.
391 */
392 }
393
394 static inline int cifs_convert_flags(unsigned
395 {
396 if ((flags & O_ACCMODE) == O_RDONLY)
397 return GENERIC_READ;
398 else if ((flags & O_ACCMODE) == O_WRON
399 return rdwr_for_fscache == 1 ?
400 else if ((flags & O_ACCMODE) == O_RDWR
401 /* GENERIC_ALL is too much per
402 can cause unnecessary acces
403 /* return GENERIC_ALL; */
404 return (GENERIC_READ | GENERIC
405 }
406
407 return (READ_CONTROL | FILE_WRITE_ATTR
408 FILE_WRITE_EA | FILE_APPEND_DA
409 FILE_READ_DATA);
410 }
411
412 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
413 static u32 cifs_posix_convert_flags(unsigned i
414 {
415 u32 posix_flags = 0;
416
417 if ((flags & O_ACCMODE) == O_RDONLY)
418 posix_flags = SMB_O_RDONLY;
419 else if ((flags & O_ACCMODE) == O_WRON
420 posix_flags = SMB_O_WRONLY;
421 else if ((flags & O_ACCMODE) == O_RDWR
422 posix_flags = SMB_O_RDWR;
423
424 if (flags & O_CREAT) {
425 posix_flags |= SMB_O_CREAT;
426 if (flags & O_EXCL)
427 posix_flags |= SMB_O_E
428 } else if (flags & O_EXCL)
429 cifs_dbg(FYI, "Application %s
430 current->comm, curren
431
432 if (flags & O_TRUNC)
433 posix_flags |= SMB_O_TRUNC;
434 /* be safe and imply O_SYNC for O_DSYN
435 if (flags & O_DSYNC)
436 posix_flags |= SMB_O_SYNC;
437 if (flags & O_DIRECTORY)
438 posix_flags |= SMB_O_DIRECTORY
439 if (flags & O_NOFOLLOW)
440 posix_flags |= SMB_O_NOFOLLOW;
441 if (flags & O_DIRECT)
442 posix_flags |= SMB_O_DIRECT;
443
444 return posix_flags;
445 }
446 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
447
448 static inline int cifs_get_disposition(unsigne
449 {
450 if ((flags & (O_CREAT | O_EXCL)) == (O
451 return FILE_CREATE;
452 else if ((flags & (O_CREAT | O_TRUNC))
453 return FILE_OVERWRITE_IF;
454 else if ((flags & O_CREAT) == O_CREAT)
455 return FILE_OPEN_IF;
456 else if ((flags & O_TRUNC) == O_TRUNC)
457 return FILE_OVERWRITE;
458 else
459 return FILE_OPEN;
460 }
461
462 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
463 int cifs_posix_open(const char *full_path, str
464 struct super_block *sb
465 __u32 *poplock, __u16
466 {
467 int rc;
468 FILE_UNIX_BASIC_INFO *presp_data;
469 __u32 posix_flags = 0;
470 struct cifs_sb_info *cifs_sb = CIFS_SB
471 struct cifs_fattr fattr;
472 struct tcon_link *tlink;
473 struct cifs_tcon *tcon;
474
475 cifs_dbg(FYI, "posix open %s\n", full_
476
477 presp_data = kzalloc(sizeof(FILE_UNIX_
478 if (presp_data == NULL)
479 return -ENOMEM;
480
481 tlink = cifs_sb_tlink(cifs_sb);
482 if (IS_ERR(tlink)) {
483 rc = PTR_ERR(tlink);
484 goto posix_open_ret;
485 }
486
487 tcon = tlink_tcon(tlink);
488 mode &= ~current_umask();
489
490 posix_flags = cifs_posix_convert_flags
491 rc = CIFSPOSIXCreate(xid, tcon, posix_
492 poplock, full_pat
493 cifs_remap(cifs_s
494 cifs_put_tlink(tlink);
495
496 if (rc)
497 goto posix_open_ret;
498
499 if (presp_data->Type == cpu_to_le32(-1
500 goto posix_open_ret; /* open o
501
502 if (!pinode)
503 goto posix_open_ret; /* caller
504
505 cifs_unix_basic_to_fattr(&fattr, presp
506
507 /* get new inode and set it up */
508 if (*pinode == NULL) {
509 cifs_fill_uniqueid(sb, &fattr)
510 *pinode = cifs_iget(sb, &fattr
511 if (!*pinode) {
512 rc = -ENOMEM;
513 goto posix_open_ret;
514 }
515 } else {
516 cifs_revalidate_mapping(*pinod
517 rc = cifs_fattr_to_inode(*pino
518 }
519
520 posix_open_ret:
521 kfree(presp_data);
522 return rc;
523 }
524 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
525
526 static int cifs_nt_open(const char *full_path,
527 struct cifs_tcon *tcon
528 struct cifs_fid *fid,
529 {
530 int rc;
531 int desired_access;
532 int disposition;
533 int create_options = CREATE_NOT_DIR;
534 struct TCP_Server_Info *server = tcon-
535 struct cifs_open_parms oparms;
536 int rdwr_for_fscache = 0;
537
538 if (!server->ops->open)
539 return -ENOSYS;
540
541 /* If we're caching, we need to be abl
542 if (cifs_fscache_enabled(inode) && (f_
543 rdwr_for_fscache = 1;
544
545 desired_access = cifs_convert_flags(f_
546
547 /*********************************************
548 * open flag mapping table:
549 *
550 * POSIX Flag CIFS Disposition
551 * ---------- ----------------
552 * O_CREAT FILE_OPEN_IF
553 * O_CREAT | O_EXCL FILE_CREATE
554 * O_CREAT | O_TRUNC FILE_OVERWRITE_I
555 * O_TRUNC FILE_OVERWRITE
556 * none of the above FILE_OPEN
557 *
558 * Note that there is not a direct match
559 * FILE_SUPERSEDE (ie create whether or n
560 * O_CREAT | O_TRUNC is similar but trunc
561 * file rather than creating a new file a
562 * (which uses the attributes / metadata
563 *?
564 *? O_SYNC is a reasonable match to CIFS writ
565 *? and the read write flags match reasonably
566 *? is irrelevant because largefile support i
567 *? by this client. Flags O_APPEND, O_DIRECT,
568 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need
569 *********************************************
570
571 disposition = cifs_get_disposition(f_f
572
573 /* BB pass O_SYNC flag through on file
574
575 /* O_SYNC also has bit for O_DSYNC so
576 if (f_flags & O_SYNC)
577 create_options |= CREATE_WRITE
578
579 if (f_flags & O_DIRECT)
580 create_options |= CREATE_NO_BU
581
582 retry_open:
583 oparms = (struct cifs_open_parms) {
584 .tcon = tcon,
585 .cifs_sb = cifs_sb,
586 .desired_access = desired_acce
587 .create_options = cifs_create_
588 .disposition = disposition,
589 .path = full_path,
590 .fid = fid,
591 };
592
593 rc = server->ops->open(xid, &oparms, o
594 if (rc) {
595 if (rc == -EACCES && rdwr_for_
596 desired_access = cifs_
597 rdwr_for_fscache = 2;
598 goto retry_open;
599 }
600 return rc;
601 }
602 if (rdwr_for_fscache == 2)
603 cifs_invalidate_cache(inode, F
604
605 /* TODO: Add support for calling posix
606 if (tcon->unix_ext)
607 rc = cifs_get_inode_info_unix(
608
609 else
610 rc = cifs_get_inode_info(&inod
611 xid,
612
613 if (rc) {
614 server->ops->close(xid, tcon,
615 if (rc == -ESTALE)
616 rc = -EOPENSTALE;
617 }
618
619 return rc;
620 }
621
622 static bool
623 cifs_has_mand_locks(struct cifsInodeInfo *cino
624 {
625 struct cifs_fid_locks *cur;
626 bool has_locks = false;
627
628 down_read(&cinode->lock_sem);
629 list_for_each_entry(cur, &cinode->llis
630 if (!list_empty(&cur->locks))
631 has_locks = true;
632 break;
633 }
634 }
635 up_read(&cinode->lock_sem);
636 return has_locks;
637 }
638
639 void
640 cifs_down_write(struct rw_semaphore *sem)
641 {
642 while (!down_write_trylock(sem))
643 msleep(10);
644 }
645
646 static void cifsFileInfo_put_work(struct work_
647 void serverclose_work(struct work_struct *work
648
649 struct cifsFileInfo *cifs_new_fileinfo(struct
650 struct
651 const c
652 {
653 struct dentry *dentry = file_dentry(fi
654 struct inode *inode = d_inode(dentry);
655 struct cifsInodeInfo *cinode = CIFS_I(
656 struct cifsFileInfo *cfile;
657 struct cifs_fid_locks *fdlocks;
658 struct cifs_tcon *tcon = tlink_tcon(tl
659 struct TCP_Server_Info *server = tcon-
660
661 cfile = kzalloc(sizeof(struct cifsFile
662 if (cfile == NULL)
663 return cfile;
664
665 fdlocks = kzalloc(sizeof(struct cifs_f
666 if (!fdlocks) {
667 kfree(cfile);
668 return NULL;
669 }
670
671 if (symlink_target) {
672 cfile->symlink_target = kstrdu
673 if (!cfile->symlink_target) {
674 kfree(fdlocks);
675 kfree(cfile);
676 return NULL;
677 }
678 }
679
680 INIT_LIST_HEAD(&fdlocks->locks);
681 fdlocks->cfile = cfile;
682 cfile->llist = fdlocks;
683
684 cfile->count = 1;
685 cfile->pid = current->tgid;
686 cfile->uid = current_fsuid();
687 cfile->dentry = dget(dentry);
688 cfile->f_flags = file->f_flags;
689 cfile->invalidHandle = false;
690 cfile->deferred_close_scheduled = fals
691 cfile->tlink = cifs_get_tlink(tlink);
692 INIT_WORK(&cfile->oplock_break, cifs_o
693 INIT_WORK(&cfile->put, cifsFileInfo_pu
694 INIT_WORK(&cfile->serverclose, serverc
695 INIT_DELAYED_WORK(&cfile->deferred, sm
696 mutex_init(&cfile->fh_mutex);
697 spin_lock_init(&cfile->file_info_lock)
698
699 cifs_sb_active(inode->i_sb);
700
701 /*
702 * If the server returned a read oploc
703 * set oplock level to None.
704 */
705 if (server->ops->is_read_op(oplock) &&
706 cifs_dbg(FYI, "Reset oplock va
707 oplock = 0;
708 }
709
710 cifs_down_write(&cinode->lock_sem);
711 list_add(&fdlocks->llist, &cinode->lli
712 up_write(&cinode->lock_sem);
713
714 spin_lock(&tcon->open_file_lock);
715 if (fid->pending_open->oplock != CIFS_
716 oplock = fid->pending_open->op
717 list_del(&fid->pending_open->olist);
718
719 fid->purge_cache = false;
720 server->ops->set_fid(cfile, fid, oploc
721
722 list_add(&cfile->tlist, &tcon->openFil
723 atomic_inc(&tcon->num_local_opens);
724
725 /* if readable file instance put first
726 spin_lock(&cinode->open_file_lock);
727 if (file->f_mode & FMODE_READ)
728 list_add(&cfile->flist, &cinod
729 else
730 list_add_tail(&cfile->flist, &
731 spin_unlock(&cinode->open_file_lock);
732 spin_unlock(&tcon->open_file_lock);
733
734 if (fid->purge_cache)
735 cifs_zap_mapping(inode);
736
737 file->private_data = cfile;
738 return cfile;
739 }
740
741 struct cifsFileInfo *
742 cifsFileInfo_get(struct cifsFileInfo *cifs_fil
743 {
744 spin_lock(&cifs_file->file_info_lock);
745 cifsFileInfo_get_locked(cifs_file);
746 spin_unlock(&cifs_file->file_info_lock
747 return cifs_file;
748 }
749
750 static void cifsFileInfo_put_final(struct cifs
751 {
752 struct inode *inode = d_inode(cifs_fil
753 struct cifsInodeInfo *cifsi = CIFS_I(i
754 struct cifsLockInfo *li, *tmp;
755 struct super_block *sb = inode->i_sb;
756
757 /*
758 * Delete any outstanding lock records
759 * is closed anyway.
760 */
761 cifs_down_write(&cifsi->lock_sem);
762 list_for_each_entry_safe(li, tmp, &cif
763 list_del(&li->llist);
764 cifs_del_lock_waiters(li);
765 kfree(li);
766 }
767 list_del(&cifs_file->llist->llist);
768 kfree(cifs_file->llist);
769 up_write(&cifsi->lock_sem);
770
771 cifs_put_tlink(cifs_file->tlink);
772 dput(cifs_file->dentry);
773 cifs_sb_deactive(sb);
774 kfree(cifs_file->symlink_target);
775 kfree(cifs_file);
776 }
777
778 static void cifsFileInfo_put_work(struct work_
779 {
780 struct cifsFileInfo *cifs_file = conta
781 struct cifsFileInfo, p
782
783 cifsFileInfo_put_final(cifs_file);
784 }
785
786 void serverclose_work(struct work_struct *work
787 {
788 struct cifsFileInfo *cifs_file = conta
789 struct cifsFileInfo, s
790
791 struct cifs_tcon *tcon = tlink_tcon(ci
792
793 struct TCP_Server_Info *server = tcon-
794 int rc = 0;
795 int retries = 0;
796 int MAX_RETRIES = 4;
797
798 do {
799 if (server->ops->close_getattr
800 rc = server->ops->clos
801 else if (server->ops->close)
802 rc = server->ops->clos
803
804 if (rc == -EBUSY || rc == -EAG
805 retries++;
806 msleep(250);
807 }
808 } while ((rc == -EBUSY || rc == -EAGAI
809 );
810
811 if (retries == MAX_RETRIES)
812 pr_warn("Serverclose failed %d
813
814 if (cifs_file->offload)
815 queue_work(fileinfo_put_wq, &c
816 else
817 cifsFileInfo_put_final(cifs_fi
818 }
819
820 /**
821 * cifsFileInfo_put - release a reference of f
822 *
823 * Always potentially wait for oplock handler.
824 *
825 * @cifs_file: cifs/smb3 specific info (eg re
826 */
827 void cifsFileInfo_put(struct cifsFileInfo *cif
828 {
829 _cifsFileInfo_put(cifs_file, true, tru
830 }
831
832 /**
833 * _cifsFileInfo_put - release a reference of
834 *
835 * This may involve closing the filehandle @ci
836 * server. Must be called without holding tcon
837 * cinode->open_file_lock and cifs_file->file_
838 *
839 * If @wait_for_oplock_handler is true and we
840 * reference, wait for any running oplock brea
841 * and cancel any pending one.
842 *
843 * @cifs_file: cifs/smb3 specific info (eg re
844 * @wait_oplock_handler: must be false if call
845 * @offload: not offloaded on close and opl
846 *
847 */
848 void _cifsFileInfo_put(struct cifsFileInfo *ci
849 bool wait_oplock_handle
850 {
851 struct inode *inode = d_inode(cifs_fil
852 struct cifs_tcon *tcon = tlink_tcon(ci
853 struct TCP_Server_Info *server = tcon-
854 struct cifsInodeInfo *cifsi = CIFS_I(i
855 struct super_block *sb = inode->i_sb;
856 struct cifs_sb_info *cifs_sb = CIFS_SB
857 struct cifs_fid fid = {};
858 struct cifs_pending_open open;
859 bool oplock_break_cancelled;
860 bool serverclose_offloaded = false;
861
862 spin_lock(&tcon->open_file_lock);
863 spin_lock(&cifsi->open_file_lock);
864 spin_lock(&cifs_file->file_info_lock);
865
866 cifs_file->offload = offload;
867 if (--cifs_file->count > 0) {
868 spin_unlock(&cifs_file->file_i
869 spin_unlock(&cifsi->open_file_
870 spin_unlock(&tcon->open_file_l
871 return;
872 }
873 spin_unlock(&cifs_file->file_info_lock
874
875 if (server->ops->get_lease_key)
876 server->ops->get_lease_key(ino
877
878 /* store open in pending opens to make
879 cifs_add_pending_open_locked(&fid, cif
880
881 /* remove it from the lists */
882 list_del(&cifs_file->flist);
883 list_del(&cifs_file->tlist);
884 atomic_dec(&tcon->num_local_opens);
885
886 if (list_empty(&cifsi->openFileList))
887 cifs_dbg(FYI, "closing last op
888 d_inode(cifs_file->de
889 /*
890 * In strict cache mode we nee
891 * close because it may cause
892 * again and get at least leve
893 */
894 if (cifs_sb->mnt_cifs_flags &
895 set_bit(CIFS_INO_INVAL
896 cifs_set_oplock_level(cifsi, 0
897 }
898
899 spin_unlock(&cifsi->open_file_lock);
900 spin_unlock(&tcon->open_file_lock);
901
902 oplock_break_cancelled = wait_oplock_h
903 cancel_work_sync(&cifs_file->o
904
905 if (!tcon->need_reconnect && !cifs_fil
906 struct TCP_Server_Info *server
907 unsigned int xid;
908 int rc = 0;
909
910 xid = get_xid();
911 if (server->ops->close_getattr
912 rc = server->ops->clos
913 else if (server->ops->close)
914 rc = server->ops->clos
915 _free_xid(xid);
916
917 if (rc == -EBUSY || rc == -EAG
918 // Server close failed
919 queue_work(serverclose
920 serverclose_offloaded
921 }
922 }
923
924 if (oplock_break_cancelled)
925 cifs_done_oplock_break(cifsi);
926
927 cifs_del_pending_open(&open);
928
929 // if serverclose has been offloaded t
930 // handle offloading put as well. If s
931 // we need to handle offloading put he
932 if (!serverclose_offloaded) {
933 if (offload)
934 queue_work(fileinfo_pu
935 else
936 cifsFileInfo_put_final
937 }
938 }
939
940 int cifs_open(struct inode *inode, struct file
941
942 {
943 int rc = -EACCES;
944 unsigned int xid;
945 __u32 oplock;
946 struct cifs_sb_info *cifs_sb;
947 struct TCP_Server_Info *server;
948 struct cifs_tcon *tcon;
949 struct tcon_link *tlink;
950 struct cifsFileInfo *cfile = NULL;
951 void *page;
952 const char *full_path;
953 bool posix_open_ok = false;
954 struct cifs_fid fid = {};
955 struct cifs_pending_open open;
956 struct cifs_open_info_data data = {};
957
958 xid = get_xid();
959
960 cifs_sb = CIFS_SB(inode->i_sb);
961 if (unlikely(cifs_forced_shutdown(cifs
962 free_xid(xid);
963 return -EIO;
964 }
965
966 tlink = cifs_sb_tlink(cifs_sb);
967 if (IS_ERR(tlink)) {
968 free_xid(xid);
969 return PTR_ERR(tlink);
970 }
971 tcon = tlink_tcon(tlink);
972 server = tcon->ses->server;
973
974 page = alloc_dentry_path();
975 full_path = build_path_from_dentry(fil
976 if (IS_ERR(full_path)) {
977 rc = PTR_ERR(full_path);
978 goto out;
979 }
980
981 cifs_dbg(FYI, "inode = 0x%p file flags
982 inode, file->f_flags, full_pa
983
984 if (file->f_flags & O_DIRECT &&
985 cifs_sb->mnt_cifs_flags & CIFS_MOU
986 if (cifs_sb->mnt_cifs_flags &
987 file->f_op = &cifs_fil
988 else
989 file->f_op = &cifs_fil
990 }
991
992 /* Get the cached handle as SMB2 close
993 rc = cifs_get_readable_path(tcon, full
994 if (rc == 0) {
995 if (file->f_flags == cfile->f_
996 file->private_data = c
997 spin_lock(&CIFS_I(inod
998 cifs_del_deferred_clos
999 spin_unlock(&CIFS_I(in
1000 goto use_cache;
1001 } else {
1002 _cifsFileInfo_put(cfi
1003 }
1004 }
1005
1006 if (server->oplocks)
1007 oplock = REQ_OPLOCK;
1008 else
1009 oplock = 0;
1010
1011 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1012 if (!tcon->broken_posix_open && tcon-
1013 cap_unix(tcon->ses) && (CIFS_UNIX
1014 le64_to_cpu(t
1015 /* can not refresh inode info
1016 rc = cifs_posix_open(full_pat
1017 cifs_sb->ctx-
1018 file->f_flags
1019 if (rc == 0) {
1020 cifs_dbg(FYI, "posix
1021 posix_open_ok = true;
1022 } else if ((rc == -EINVAL) ||
1023 if (tcon->ses->server
1024 cifs_dbg(VFS,
1025 tcon
1026 tcon
1027 tcon->broken_posix_op
1028 } else if ((rc != -EIO) && (r
1029 (rc != -EOPNOTSUPP))
1030 goto out;
1031 /*
1032 * Else fallthrough to retry
1033 * or DFS errors.
1034 */
1035 }
1036 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
1037
1038 if (server->ops->get_lease_key)
1039 server->ops->get_lease_key(in
1040
1041 cifs_add_pending_open(&fid, tlink, &o
1042
1043 if (!posix_open_ok) {
1044 if (server->ops->get_lease_ke
1045 server->ops->get_leas
1046
1047 rc = cifs_nt_open(full_path,
1048 xid, &data)
1049 if (rc) {
1050 cifs_del_pending_open
1051 goto out;
1052 }
1053 }
1054
1055 cfile = cifs_new_fileinfo(&fid, file,
1056 if (cfile == NULL) {
1057 if (server->ops->close)
1058 server->ops->close(xi
1059 cifs_del_pending_open(&open);
1060 rc = -ENOMEM;
1061 goto out;
1062 }
1063
1064 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1065 if ((oplock & CIFS_CREATE_ACTION) &&
1066 /*
1067 * Time to set mode which we
1068 * problems creating new read
1069 */
1070 struct cifs_unix_set_info_arg
1071 .mode = inode->i_mo
1072 .uid = INVALID_UID
1073 .gid = INVALID_GID
1074 .ctime = NO_CHANGE_6
1075 .atime = NO_CHANGE_6
1076 .mtime = NO_CHANGE_6
1077 .device = 0,
1078 };
1079 CIFSSMBUnixSetFileInfo(xid, t
1080 cfile-
1081 }
1082 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
1083
1084 use_cache:
1085 fscache_use_cookie(cifs_inode_cookie(
1086 file->f_mode & FMO
1087 if (!(file->f_flags & O_DIRECT))
1088 goto out;
1089 if ((file->f_flags & (O_ACCMODE | O_A
1090 goto out;
1091 cifs_invalidate_cache(file_inode(file
1092
1093 out:
1094 free_dentry_path(page);
1095 free_xid(xid);
1096 cifs_put_tlink(tlink);
1097 cifs_free_open_info(&data);
1098 return rc;
1099 }
1100
1101 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1102 static int cifs_push_posix_locks(struct cifsF
1103 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
1104
1105 /*
1106 * Try to reacquire byte range locks that wer
1107 * to server was lost.
1108 */
1109 static int
1110 cifs_relock_file(struct cifsFileInfo *cfile)
1111 {
1112 struct cifsInodeInfo *cinode = CIFS_I
1113 struct cifs_tcon *tcon = tlink_tcon(c
1114 int rc = 0;
1115 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1116 struct cifs_sb_info *cifs_sb = CIFS_S
1117 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
1118
1119 down_read_nested(&cinode->lock_sem, S
1120 if (cinode->can_cache_brlcks) {
1121 /* can cache locks - no need
1122 up_read(&cinode->lock_sem);
1123 return rc;
1124 }
1125
1126 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1127 if (cap_unix(tcon->ses) &&
1128 (CIFS_UNIX_FCNTL_CAP & le64_to_cp
1129 ((cifs_sb->mnt_cifs_flags & CIFS_
1130 rc = cifs_push_posix_locks(cf
1131 else
1132 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
1133 rc = tcon->ses->server->ops->
1134
1135 up_read(&cinode->lock_sem);
1136 return rc;
1137 }
1138
1139 static int
1140 cifs_reopen_file(struct cifsFileInfo *cfile,
1141 {
1142 int rc = -EACCES;
1143 unsigned int xid;
1144 __u32 oplock;
1145 struct cifs_sb_info *cifs_sb;
1146 struct cifs_tcon *tcon;
1147 struct TCP_Server_Info *server;
1148 struct cifsInodeInfo *cinode;
1149 struct inode *inode;
1150 void *page;
1151 const char *full_path;
1152 int desired_access;
1153 int disposition = FILE_OPEN;
1154 int create_options = CREATE_NOT_DIR;
1155 struct cifs_open_parms oparms;
1156 int rdwr_for_fscache = 0;
1157
1158 xid = get_xid();
1159 mutex_lock(&cfile->fh_mutex);
1160 if (!cfile->invalidHandle) {
1161 mutex_unlock(&cfile->fh_mutex
1162 free_xid(xid);
1163 return 0;
1164 }
1165
1166 inode = d_inode(cfile->dentry);
1167 cifs_sb = CIFS_SB(inode->i_sb);
1168 tcon = tlink_tcon(cfile->tlink);
1169 server = tcon->ses->server;
1170
1171 /*
1172 * Can not grab rename sem here becau
1173 * that already have the rename sem c
1174 * called and if the server was down
1175 * can never tell if the caller alrea
1176 */
1177 page = alloc_dentry_path();
1178 full_path = build_path_from_dentry(cf
1179 if (IS_ERR(full_path)) {
1180 mutex_unlock(&cfile->fh_mutex
1181 free_dentry_path(page);
1182 free_xid(xid);
1183 return PTR_ERR(full_path);
1184 }
1185
1186 cifs_dbg(FYI, "inode = 0x%p file flag
1187 inode, cfile->f_flags, full_
1188
1189 if (tcon->ses->server->oplocks)
1190 oplock = REQ_OPLOCK;
1191 else
1192 oplock = 0;
1193
1194 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1195 if (tcon->unix_ext && cap_unix(tcon->
1196 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1197 le64_to_cpu(t
1198 /*
1199 * O_CREAT, O_EXCL and O_TRUN
1200 * original open. Must mask t
1201 */
1202 unsigned int oflags = cfile->
1203
1204
1205 rc = cifs_posix_open(full_pat
1206 cifs_sb-
1207 oflags,
1208 if (rc == 0) {
1209 cifs_dbg(FYI, "posix
1210 oparms.reconnect = tr
1211 goto reopen_success;
1212 }
1213 /*
1214 * fallthrough to retry open
1215 * in the reconnect path it i
1216 */
1217 }
1218 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
1219
1220 /* If we're caching, we need to be ab
1221 if (cifs_fscache_enabled(inode) && (c
1222 rdwr_for_fscache = 1;
1223
1224 desired_access = cifs_convert_flags(c
1225
1226 /* O_SYNC also has bit for O_DSYNC so
1227 if (cfile->f_flags & O_SYNC)
1228 create_options |= CREATE_WRIT
1229
1230 if (cfile->f_flags & O_DIRECT)
1231 create_options |= CREATE_NO_B
1232
1233 if (server->ops->get_lease_key)
1234 server->ops->get_lease_key(in
1235
1236 retry_open:
1237 oparms = (struct cifs_open_parms) {
1238 .tcon = tcon,
1239 .cifs_sb = cifs_sb,
1240 .desired_access = desired_acc
1241 .create_options = cifs_create
1242 .disposition = disposition,
1243 .path = full_path,
1244 .fid = &cfile->fid,
1245 .reconnect = true,
1246 };
1247
1248 /*
1249 * Can not refresh inode by passing i
1250 * ops->open and then calling get_ino
1251 * file might have write behind data
1252 * version of file size can be stale.
1253 * not dirty locally we could do this
1254 */
1255 rc = server->ops->open(xid, &oparms,
1256 if (rc == -ENOENT && oparms.reconnect
1257 /* durable handle timeout is
1258 rc = server->ops->open(xid, &
1259 /* indicate that we need to r
1260 oparms.reconnect = true;
1261 }
1262 if (rc == -EACCES && rdwr_for_fscache
1263 desired_access = cifs_convert
1264 rdwr_for_fscache = 2;
1265 goto retry_open;
1266 }
1267
1268 if (rc) {
1269 mutex_unlock(&cfile->fh_mutex
1270 cifs_dbg(FYI, "cifs_reopen re
1271 cifs_dbg(FYI, "oplock: %d\n",
1272 goto reopen_error_exit;
1273 }
1274
1275 if (rdwr_for_fscache == 2)
1276 cifs_invalidate_cache(inode,
1277
1278 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1279 reopen_success:
1280 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
1281 cfile->invalidHandle = false;
1282 mutex_unlock(&cfile->fh_mutex);
1283 cinode = CIFS_I(inode);
1284
1285 if (can_flush) {
1286 rc = filemap_write_and_wait(i
1287 if (!is_interrupt_error(rc))
1288 mapping_set_error(ino
1289
1290 if (tcon->posix_extensions) {
1291 rc = smb311_posix_get
1292
1293 } else if (tcon->unix_ext) {
1294 rc = cifs_get_inode_i
1295
1296 } else {
1297 rc = cifs_get_inode_i
1298
1299 }
1300 }
1301 /*
1302 * Else we are writing out data to se
1303 * we tried to flush data, and since
1304 * would invalidate the current end o
1305 * to the server to get the new inode
1306 */
1307
1308 /*
1309 * If the server returned a read oplo
1310 * set oplock level to None.
1311 */
1312 if (server->ops->is_read_op(oplock) &
1313 cifs_dbg(FYI, "Reset oplock v
1314 oplock = 0;
1315 }
1316
1317 server->ops->set_fid(cfile, &cfile->f
1318 if (oparms.reconnect)
1319 cifs_relock_file(cfile);
1320
1321 reopen_error_exit:
1322 free_dentry_path(page);
1323 free_xid(xid);
1324 return rc;
1325 }
1326
1327 void smb2_deferred_work_close(struct work_str
1328 {
1329 struct cifsFileInfo *cfile = containe
1330 struct cifsFileInfo,
1331
1332 spin_lock(&CIFS_I(d_inode(cfile->dent
1333 cifs_del_deferred_close(cfile);
1334 cfile->deferred_close_scheduled = fal
1335 spin_unlock(&CIFS_I(d_inode(cfile->de
1336 _cifsFileInfo_put(cfile, true, false)
1337 }
1338
1339 static bool
1340 smb2_can_defer_close(struct inode *inode, str
1341 {
1342 struct cifs_sb_info *cifs_sb = CIFS_S
1343 struct cifsInodeInfo *cinode = CIFS_I
1344
1345 return (cifs_sb->ctx->closetimeo && c
1346 (cinode->oplock == CI
1347 cinode->oplock == CI
1348 !test_bit(CIFS_INO_CL
1349
1350 }
1351
1352 int cifs_close(struct inode *inode, struct fi
1353 {
1354 struct cifsFileInfo *cfile;
1355 struct cifsInodeInfo *cinode = CIFS_I
1356 struct cifs_sb_info *cifs_sb = CIFS_S
1357 struct cifs_deferred_close *dclose;
1358
1359 cifs_fscache_unuse_inode_cookie(inode
1360
1361 if (file->private_data != NULL) {
1362 cfile = file->private_data;
1363 file->private_data = NULL;
1364 dclose = kmalloc(sizeof(struc
1365 if ((cfile->status_file_delet
1366 (smb2_can_defer_close(ino
1367 if (test_and_clear_bi
1368 inode_set_mti
1369
1370 }
1371 spin_lock(&cinode->de
1372 cifs_add_deferred_clo
1373 if (cfile->deferred_c
1374 delayed_work_pend
1375 /*
1376 * If there i
1377 * So, Increa
1378 */
1379 if (!mod_dela
1380
1381 cifsF
1382 } else {
1383 /* Deferred c
1384 queue_delayed
1385
1386 cfile->deferr
1387 spin_unlock(&
1388 return 0;
1389 }
1390 spin_unlock(&cinode->
1391 _cifsFileInfo_put(cfi
1392 } else {
1393 _cifsFileInfo_put(cfi
1394 kfree(dclose);
1395 }
1396 }
1397
1398 /* return code from the ->release op
1399 return 0;
1400 }
1401
1402 void
1403 cifs_reopen_persistent_handles(struct cifs_tc
1404 {
1405 struct cifsFileInfo *open_file, *tmp;
1406 LIST_HEAD(tmp_list);
1407
1408 if (!tcon->use_persistent || !tcon->n
1409 return;
1410
1411 tcon->need_reopen_files = false;
1412
1413 cifs_dbg(FYI, "Reopen persistent hand
1414
1415 /* list all files open on tree connec
1416 spin_lock(&tcon->open_file_lock);
1417 list_for_each_entry(open_file, &tcon-
1418 if (!open_file->invalidHandle
1419 continue;
1420 cifsFileInfo_get(open_file);
1421 list_add_tail(&open_file->rli
1422 }
1423 spin_unlock(&tcon->open_file_lock);
1424
1425 list_for_each_entry_safe(open_file, t
1426 if (cifs_reopen_file(open_fil
1427 tcon->need_reopen_fil
1428 list_del_init(&open_file->rli
1429 cifsFileInfo_put(open_file);
1430 }
1431 }
1432
1433 int cifs_closedir(struct inode *inode, struct
1434 {
1435 int rc = 0;
1436 unsigned int xid;
1437 struct cifsFileInfo *cfile = file->pr
1438 struct cifs_tcon *tcon;
1439 struct TCP_Server_Info *server;
1440 char *buf;
1441
1442 cifs_dbg(FYI, "Closedir inode = 0x%p\
1443
1444 if (cfile == NULL)
1445 return rc;
1446
1447 xid = get_xid();
1448 tcon = tlink_tcon(cfile->tlink);
1449 server = tcon->ses->server;
1450
1451 cifs_dbg(FYI, "Freeing private data i
1452 spin_lock(&cfile->file_info_lock);
1453 if (server->ops->dir_needs_close(cfil
1454 cfile->invalidHandle = true;
1455 spin_unlock(&cfile->file_info
1456 if (server->ops->close_dir)
1457 rc = server->ops->clo
1458 else
1459 rc = -ENOSYS;
1460 cifs_dbg(FYI, "Closing uncomp
1461 /* not much we can do if it f
1462 rc = 0;
1463 } else
1464 spin_unlock(&cfile->file_info
1465
1466 buf = cfile->srch_inf.ntwrk_buf_start
1467 if (buf) {
1468 cifs_dbg(FYI, "closedir free
1469 cfile->srch_inf.ntwrk_buf_sta
1470 if (cfile->srch_inf.smallBuf)
1471 cifs_small_buf_releas
1472 else
1473 cifs_buf_release(buf)
1474 }
1475
1476 cifs_put_tlink(cfile->tlink);
1477 kfree(file->private_data);
1478 file->private_data = NULL;
1479 /* BB can we lock the filestruct whil
1480 free_xid(xid);
1481 return rc;
1482 }
1483
1484 static struct cifsLockInfo *
1485 cifs_lock_init(__u64 offset, __u64 length, __
1486 {
1487 struct cifsLockInfo *lock =
1488 kmalloc(sizeof(struct cifsLoc
1489 if (!lock)
1490 return lock;
1491 lock->offset = offset;
1492 lock->length = length;
1493 lock->type = type;
1494 lock->pid = current->tgid;
1495 lock->flags = flags;
1496 INIT_LIST_HEAD(&lock->blist);
1497 init_waitqueue_head(&lock->block_q);
1498 return lock;
1499 }
1500
1501 void
1502 cifs_del_lock_waiters(struct cifsLockInfo *lo
1503 {
1504 struct cifsLockInfo *li, *tmp;
1505 list_for_each_entry_safe(li, tmp, &lo
1506 list_del_init(&li->blist);
1507 wake_up(&li->block_q);
1508 }
1509 }
1510
1511 #define CIFS_LOCK_OP 0
1512 #define CIFS_READ_OP 1
1513 #define CIFS_WRITE_OP 2
1514
1515 /* @rw_check : 0 - no op, 1 - read, 2 - write
1516 static bool
1517 cifs_find_fid_lock_conflict(struct cifs_fid_l
1518 __u64 length, __u
1519 struct cifsFileIn
1520 struct cifsLockIn
1521 {
1522 struct cifsLockInfo *li;
1523 struct cifsFileInfo *cur_cfile = fdlo
1524 struct TCP_Server_Info *server = tlin
1525
1526 list_for_each_entry(li, &fdlocks->loc
1527 if (offset + length <= li->of
1528 offset >= li->offset + li
1529 continue;
1530 if (rw_check != CIFS_LOCK_OP
1531 server->ops->compare_fids
1532 /* shared lock preven
1533 if (!(li->type & serv
1534 rw_check != CIFS_
1535 continue;
1536 }
1537 if ((type & server->vals->sha
1538 ((server->ops->compare_fi
1539 current->tgid == li->pid
1540 continue;
1541 if (rw_check == CIFS_LOCK_OP
1542 (flags & FL_OFDLCK) && (l
1543 server->ops->compare_fids
1544 continue;
1545 if (conf_lock)
1546 *conf_lock = li;
1547 return true;
1548 }
1549 return false;
1550 }
1551
1552 bool
1553 cifs_find_lock_conflict(struct cifsFileInfo *
1554 __u8 type, __u16 flag
1555 struct cifsLockInfo *
1556 {
1557 bool rc = false;
1558 struct cifs_fid_locks *cur;
1559 struct cifsInodeInfo *cinode = CIFS_I
1560
1561 list_for_each_entry(cur, &cinode->lli
1562 rc = cifs_find_fid_lock_confl
1563
1564
1565 if (rc)
1566 break;
1567 }
1568
1569 return rc;
1570 }
1571
1572 /*
1573 * Check if there is another lock that preven
1574 * style). If such a lock exists, update the
1575 * properties. Otherwise, set the flock type
1576 * or leave it the same if we can't. Returns
1577 * the server or 1 otherwise.
1578 */
1579 static int
1580 cifs_lock_test(struct cifsFileInfo *cfile, __
1581 __u8 type, struct file_lock *f
1582 {
1583 int rc = 0;
1584 struct cifsLockInfo *conf_lock;
1585 struct cifsInodeInfo *cinode = CIFS_I
1586 struct TCP_Server_Info *server = tlin
1587 bool exist;
1588
1589 down_read(&cinode->lock_sem);
1590
1591 exist = cifs_find_lock_conflict(cfile
1592 flock
1593 CIFS_
1594 if (exist) {
1595 flock->fl_start = conf_lock->
1596 flock->fl_end = conf_lock->of
1597 flock->c.flc_pid = conf_lock-
1598 if (conf_lock->type & server-
1599 flock->c.flc_type = F
1600 else
1601 flock->c.flc_type = F
1602 } else if (!cinode->can_cache_brlcks)
1603 rc = 1;
1604 else
1605 flock->c.flc_type = F_UNLCK;
1606
1607 up_read(&cinode->lock_sem);
1608 return rc;
1609 }
1610
1611 static void
1612 cifs_lock_add(struct cifsFileInfo *cfile, str
1613 {
1614 struct cifsInodeInfo *cinode = CIFS_I
1615 cifs_down_write(&cinode->lock_sem);
1616 list_add_tail(&lock->llist, &cfile->l
1617 up_write(&cinode->lock_sem);
1618 }
1619
1620 /*
1621 * Set the byte-range lock (mandatory style).
1622 * 1) 0, if we set the lock and don't need to
1623 * 2) 1, if no locks prevent us but we need t
1624 * 3) -EACCES, if there is a lock that preven
1625 */
1626 static int
1627 cifs_lock_add_if(struct cifsFileInfo *cfile,
1628 bool wait)
1629 {
1630 struct cifsLockInfo *conf_lock;
1631 struct cifsInodeInfo *cinode = CIFS_I
1632 bool exist;
1633 int rc = 0;
1634
1635 try_again:
1636 exist = false;
1637 cifs_down_write(&cinode->lock_sem);
1638
1639 exist = cifs_find_lock_conflict(cfile
1640 lock-
1641 CIFS_
1642 if (!exist && cinode->can_cache_brlck
1643 list_add_tail(&lock->llist, &
1644 up_write(&cinode->lock_sem);
1645 return rc;
1646 }
1647
1648 if (!exist)
1649 rc = 1;
1650 else if (!wait)
1651 rc = -EACCES;
1652 else {
1653 list_add_tail(&lock->blist, &
1654 up_write(&cinode->lock_sem);
1655 rc = wait_event_interruptible
1656 (lock
1657 (lock
1658 if (!rc)
1659 goto try_again;
1660 cifs_down_write(&cinode->lock
1661 list_del_init(&lock->blist);
1662 }
1663
1664 up_write(&cinode->lock_sem);
1665 return rc;
1666 }
1667
1668 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1669 /*
1670 * Check if there is another lock that preven
1671 * style). If such a lock exists, update the
1672 * properties. Otherwise, set the flock type
1673 * or leave it the same if we can't. Returns
1674 * the server or 1 otherwise.
1675 */
1676 static int
1677 cifs_posix_lock_test(struct file *file, struc
1678 {
1679 int rc = 0;
1680 struct cifsInodeInfo *cinode = CIFS_I
1681 unsigned char saved_type = flock->c.f
1682
1683 if ((flock->c.flc_flags & FL_POSIX) =
1684 return 1;
1685
1686 down_read(&cinode->lock_sem);
1687 posix_test_lock(file, flock);
1688
1689 if (lock_is_unlock(flock) && !cinode-
1690 flock->c.flc_type = saved_typ
1691 rc = 1;
1692 }
1693
1694 up_read(&cinode->lock_sem);
1695 return rc;
1696 }
1697
1698 /*
1699 * Set the byte-range lock (posix style). Ret
1700 * 1) <0, if the error occurs while setting t
1701 * 2) 0, if we set the lock and don't need to
1702 * 3) FILE_LOCK_DEFERRED, if we will wait for
1703 * 4) FILE_LOCK_DEFERRED + 1, if we need to r
1704 */
1705 static int
1706 cifs_posix_lock_set(struct file *file, struct
1707 {
1708 struct cifsInodeInfo *cinode = CIFS_I
1709 int rc = FILE_LOCK_DEFERRED + 1;
1710
1711 if ((flock->c.flc_flags & FL_POSIX) =
1712 return rc;
1713
1714 cifs_down_write(&cinode->lock_sem);
1715 if (!cinode->can_cache_brlcks) {
1716 up_write(&cinode->lock_sem);
1717 return rc;
1718 }
1719
1720 rc = posix_lock_file(file, flock, NUL
1721 up_write(&cinode->lock_sem);
1722 return rc;
1723 }
1724
1725 int
1726 cifs_push_mandatory_locks(struct cifsFileInfo
1727 {
1728 unsigned int xid;
1729 int rc = 0, stored_rc;
1730 struct cifsLockInfo *li, *tmp;
1731 struct cifs_tcon *tcon;
1732 unsigned int num, max_num, max_buf;
1733 LOCKING_ANDX_RANGE *buf, *cur;
1734 static const int types[] = {
1735 LOCKING_ANDX_LARGE_FILES,
1736 LOCKING_ANDX_SHARED_LOCK | LO
1737 };
1738 int i;
1739
1740 xid = get_xid();
1741 tcon = tlink_tcon(cfile->tlink);
1742
1743 /*
1744 * Accessing maxBuf is racy with cifs
1745 * and check it before using.
1746 */
1747 max_buf = tcon->ses->server->maxBuf;
1748 if (max_buf < (sizeof(struct smb_hdr)
1749 free_xid(xid);
1750 return -EINVAL;
1751 }
1752
1753 BUILD_BUG_ON(sizeof(struct smb_hdr) +
1754 PAGE_SIZE);
1755 max_buf = min_t(unsigned int, max_buf
1756 PAGE_SIZE);
1757 max_num = (max_buf - sizeof(struct sm
1758
1759 buf = kcalloc(max_num, sizeof(LOCKING
1760 if (!buf) {
1761 free_xid(xid);
1762 return -ENOMEM;
1763 }
1764
1765 for (i = 0; i < 2; i++) {
1766 cur = buf;
1767 num = 0;
1768 list_for_each_entry_safe(li,
1769 if (li->type != types
1770 continue;
1771 cur->Pid = cpu_to_le1
1772 cur->LengthLow = cpu_
1773 cur->LengthHigh = cpu
1774 cur->OffsetLow = cpu_
1775 cur->OffsetHigh = cpu
1776 if (++num == max_num)
1777 stored_rc = c
1778
1779
1780
1781 if (stored_rc
1782 rc =
1783 cur = buf;
1784 num = 0;
1785 } else
1786 cur++;
1787 }
1788
1789 if (num) {
1790 stored_rc = cifs_lock
1791
1792 if (stored_rc)
1793 rc = stored_r
1794 }
1795 }
1796
1797 kfree(buf);
1798 free_xid(xid);
1799 return rc;
1800 }
1801
1802 static __u32
1803 hash_lockowner(fl_owner_t owner)
1804 {
1805 return cifs_lock_secret ^ hash32_ptr(
1806 }
1807 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
1808
1809 struct lock_to_push {
1810 struct list_head llist;
1811 __u64 offset;
1812 __u64 length;
1813 __u32 pid;
1814 __u16 netfid;
1815 __u8 type;
1816 };
1817
1818 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1819 static int
1820 cifs_push_posix_locks(struct cifsFileInfo *cf
1821 {
1822 struct inode *inode = d_inode(cfile->
1823 struct cifs_tcon *tcon = tlink_tcon(c
1824 struct file_lock *flock;
1825 struct file_lock_context *flctx = loc
1826 unsigned int count = 0, i;
1827 int rc = 0, xid, type;
1828 struct list_head locks_to_send, *el;
1829 struct lock_to_push *lck, *tmp;
1830 __u64 length;
1831
1832 xid = get_xid();
1833
1834 if (!flctx)
1835 goto out;
1836
1837 spin_lock(&flctx->flc_lock);
1838 list_for_each(el, &flctx->flc_posix)
1839 count++;
1840 }
1841 spin_unlock(&flctx->flc_lock);
1842
1843 INIT_LIST_HEAD(&locks_to_send);
1844
1845 /*
1846 * Allocating count locks is enough b
1847 * added to the list while we are hol
1848 * protects locking operations of thi
1849 */
1850 for (i = 0; i < count; i++) {
1851 lck = kmalloc(sizeof(struct l
1852 if (!lck) {
1853 rc = -ENOMEM;
1854 goto err_out;
1855 }
1856 list_add_tail(&lck->llist, &l
1857 }
1858
1859 el = locks_to_send.next;
1860 spin_lock(&flctx->flc_lock);
1861 for_each_file_lock(flock, &flctx->flc
1862 unsigned char ftype = flock->
1863
1864 if (el == &locks_to_send) {
1865 /*
1866 * The list ended. We
1867 * structures - somet
1868 */
1869 cifs_dbg(VFS, "Can't
1870 break;
1871 }
1872 length = cifs_flock_len(flock
1873 if (ftype == F_RDLCK || ftype
1874 type = CIFS_RDLCK;
1875 else
1876 type = CIFS_WRLCK;
1877 lck = list_entry(el, struct l
1878 lck->pid = hash_lockowner(flo
1879 lck->netfid = cfile->fid.netf
1880 lck->length = length;
1881 lck->type = type;
1882 lck->offset = flock->fl_start
1883 }
1884 spin_unlock(&flctx->flc_lock);
1885
1886 list_for_each_entry_safe(lck, tmp, &l
1887 int stored_rc;
1888
1889 stored_rc = CIFSSMBPosixLock(
1890
1891
1892 if (stored_rc)
1893 rc = stored_rc;
1894 list_del(&lck->llist);
1895 kfree(lck);
1896 }
1897
1898 out:
1899 free_xid(xid);
1900 return rc;
1901 err_out:
1902 list_for_each_entry_safe(lck, tmp, &l
1903 list_del(&lck->llist);
1904 kfree(lck);
1905 }
1906 goto out;
1907 }
1908 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
1909
1910 static int
1911 cifs_push_locks(struct cifsFileInfo *cfile)
1912 {
1913 struct cifsInodeInfo *cinode = CIFS_I
1914 struct cifs_tcon *tcon = tlink_tcon(c
1915 int rc = 0;
1916 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1917 struct cifs_sb_info *cifs_sb = CIFS_S
1918 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
1919
1920 /* we are going to update can_cache_b
1921 cifs_down_write(&cinode->lock_sem);
1922 if (!cinode->can_cache_brlcks) {
1923 up_write(&cinode->lock_sem);
1924 return rc;
1925 }
1926
1927 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1928 if (cap_unix(tcon->ses) &&
1929 (CIFS_UNIX_FCNTL_CAP & le64_to_cp
1930 ((cifs_sb->mnt_cifs_flags & CIFS_
1931 rc = cifs_push_posix_locks(cf
1932 else
1933 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
1934 rc = tcon->ses->server->ops->
1935
1936 cinode->can_cache_brlcks = false;
1937 up_write(&cinode->lock_sem);
1938 return rc;
1939 }
1940
1941 static void
1942 cifs_read_flock(struct file_lock *flock, __u3
1943 bool *wait_flag, struct TCP_S
1944 {
1945 if (flock->c.flc_flags & FL_POSIX)
1946 cifs_dbg(FYI, "Posix\n");
1947 if (flock->c.flc_flags & FL_FLOCK)
1948 cifs_dbg(FYI, "Flock\n");
1949 if (flock->c.flc_flags & FL_SLEEP) {
1950 cifs_dbg(FYI, "Blocking lock\
1951 *wait_flag = true;
1952 }
1953 if (flock->c.flc_flags & FL_ACCESS)
1954 cifs_dbg(FYI, "Process suspen
1955 if (flock->c.flc_flags & FL_LEASE)
1956 cifs_dbg(FYI, "Lease on file
1957 if (flock->c.flc_flags &
1958 (~(FL_POSIX | FL_FLOCK | FL_SLEEP
1959 FL_ACCESS | FL_LEASE | FL_CLOS
1960 cifs_dbg(FYI, "Unknown lock f
1961 flock->c.flc_flags);
1962
1963 *type = server->vals->large_lock_type
1964 if (lock_is_write(flock)) {
1965 cifs_dbg(FYI, "F_WRLCK\n");
1966 *type |= server->vals->exclus
1967 *lock = 1;
1968 } else if (lock_is_unlock(flock)) {
1969 cifs_dbg(FYI, "F_UNLCK\n");
1970 *type |= server->vals->unlock
1971 *unlock = 1;
1972 /* Check if unlock includes m
1973 } else if (lock_is_read(flock)) {
1974 cifs_dbg(FYI, "F_RDLCK\n");
1975 *type |= server->vals->shared
1976 *lock = 1;
1977 } else if (flock->c.flc_type == F_EXL
1978 cifs_dbg(FYI, "F_EXLCK\n");
1979 *type |= server->vals->exclus
1980 *lock = 1;
1981 } else if (flock->c.flc_type == F_SHL
1982 cifs_dbg(FYI, "F_SHLCK\n");
1983 *type |= server->vals->shared
1984 *lock = 1;
1985 } else
1986 cifs_dbg(FYI, "Unknown type o
1987 }
1988
1989 static int
1990 cifs_getlk(struct file *file, struct file_loc
1991 bool wait_flag, bool posix_lck, un
1992 {
1993 int rc = 0;
1994 __u64 length = cifs_flock_len(flock);
1995 struct cifsFileInfo *cfile = (struct
1996 struct cifs_tcon *tcon = tlink_tcon(c
1997 struct TCP_Server_Info *server = tcon
1998 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1999 __u16 netfid = cfile->fid.netfid;
2000
2001 if (posix_lck) {
2002 int posix_lock_type;
2003
2004 rc = cifs_posix_lock_test(fil
2005 if (!rc)
2006 return rc;
2007
2008 if (type & server->vals->shar
2009 posix_lock_type = CIF
2010 else
2011 posix_lock_type = CIF
2012 rc = CIFSSMBPosixLock(xid, tc
2013 hash_lo
2014 flock->
2015 posix_l
2016 return rc;
2017 }
2018 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
2019
2020 rc = cifs_lock_test(cfile, flock->fl_
2021 if (!rc)
2022 return rc;
2023
2024 /* BB we could chain these into one l
2025 rc = server->ops->mand_lock(xid, cfil
2026 1, 0, fal
2027 if (rc == 0) {
2028 rc = server->ops->mand_lock(x
2029 t
2030 flock->c.flc_type = F_UNLCK;
2031 if (rc != 0)
2032 cifs_dbg(VFS, "Error
2033 rc);
2034 return 0;
2035 }
2036
2037 if (type & server->vals->shared_lock_
2038 flock->c.flc_type = F_WRLCK;
2039 return 0;
2040 }
2041
2042 type &= ~server->vals->exclusive_lock
2043
2044 rc = server->ops->mand_lock(xid, cfil
2045 type | se
2046 1, 0, fal
2047 if (rc == 0) {
2048 rc = server->ops->mand_lock(x
2049 type | server->vals->
2050 flock->c.flc_type = F_RDLCK;
2051 if (rc != 0)
2052 cifs_dbg(VFS, "Error
2053 rc);
2054 } else
2055 flock->c.flc_type = F_WRLCK;
2056
2057 return 0;
2058 }
2059
2060 void
2061 cifs_move_llist(struct list_head *source, str
2062 {
2063 struct list_head *li, *tmp;
2064 list_for_each_safe(li, tmp, source)
2065 list_move(li, dest);
2066 }
2067
2068 void
2069 cifs_free_llist(struct list_head *llist)
2070 {
2071 struct cifsLockInfo *li, *tmp;
2072 list_for_each_entry_safe(li, tmp, lli
2073 cifs_del_lock_waiters(li);
2074 list_del(&li->llist);
2075 kfree(li);
2076 }
2077 }
2078
2079 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2080 int
2081 cifs_unlock_range(struct cifsFileInfo *cfile,
2082 unsigned int xid)
2083 {
2084 int rc = 0, stored_rc;
2085 static const int types[] = {
2086 LOCKING_ANDX_LARGE_FILES,
2087 LOCKING_ANDX_SHARED_LOCK | LO
2088 };
2089 unsigned int i;
2090 unsigned int max_num, num, max_buf;
2091 LOCKING_ANDX_RANGE *buf, *cur;
2092 struct cifs_tcon *tcon = tlink_tcon(c
2093 struct cifsInodeInfo *cinode = CIFS_I
2094 struct cifsLockInfo *li, *tmp;
2095 __u64 length = cifs_flock_len(flock);
2096 LIST_HEAD(tmp_llist);
2097
2098 /*
2099 * Accessing maxBuf is racy with cifs
2100 * and check it before using.
2101 */
2102 max_buf = tcon->ses->server->maxBuf;
2103 if (max_buf < (sizeof(struct smb_hdr)
2104 return -EINVAL;
2105
2106 BUILD_BUG_ON(sizeof(struct smb_hdr) +
2107 PAGE_SIZE);
2108 max_buf = min_t(unsigned int, max_buf
2109 PAGE_SIZE);
2110 max_num = (max_buf - sizeof(struct sm
2111
2112 buf = kcalloc(max_num, sizeof(LOCKING
2113 if (!buf)
2114 return -ENOMEM;
2115
2116 cifs_down_write(&cinode->lock_sem);
2117 for (i = 0; i < 2; i++) {
2118 cur = buf;
2119 num = 0;
2120 list_for_each_entry_safe(li,
2121 if (flock->fl_start >
2122 (flock->fl_start
2123 (li->offset + li-
2124 continue;
2125 if (current->tgid !=
2126 continue;
2127 if (types[i] != li->t
2128 continue;
2129 if (cinode->can_cache
2130 /*
2131 * We can cac
2132 * a lock fro
2133 */
2134 list_del(&li-
2135 cifs_del_lock
2136 kfree(li);
2137 continue;
2138 }
2139 cur->Pid = cpu_to_le1
2140 cur->LengthLow = cpu_
2141 cur->LengthHigh = cpu
2142 cur->OffsetLow = cpu_
2143 cur->OffsetHigh = cpu
2144 /*
2145 * We need to save a
2146 * the file's list if
2147 * the server.
2148 */
2149 list_move(&li->llist,
2150 if (++num == max_num)
2151 stored_rc = c
2152
2153
2154 if (stored_rc
2155 /*
2156 * We
2157 * re
2158 * li
2159 */
2160 cifs_
2161
2162 rc =
2163 } else
2164 /*
2165 * Th
2166 * fr
2167 */
2168 cifs_
2169 cur = buf;
2170 num = 0;
2171 } else
2172 cur++;
2173 }
2174 if (num) {
2175 stored_rc = cifs_lock
2176
2177 if (stored_rc) {
2178 cifs_move_lli
2179
2180 rc = stored_r
2181 } else
2182 cifs_free_lli
2183 }
2184 }
2185
2186 up_write(&cinode->lock_sem);
2187 kfree(buf);
2188 return rc;
2189 }
2190 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
2191
2192 static int
2193 cifs_setlk(struct file *file, struct file_loc
2194 bool wait_flag, bool posix_lck, in
2195 unsigned int xid)
2196 {
2197 int rc = 0;
2198 __u64 length = cifs_flock_len(flock);
2199 struct cifsFileInfo *cfile = (struct
2200 struct cifs_tcon *tcon = tlink_tcon(c
2201 struct TCP_Server_Info *server = tcon
2202 struct inode *inode = d_inode(cfile->
2203
2204 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2205 if (posix_lck) {
2206 int posix_lock_type;
2207
2208 rc = cifs_posix_lock_set(file
2209 if (rc <= FILE_LOCK_DEFERRED)
2210 return rc;
2211
2212 if (type & server->vals->shar
2213 posix_lock_type = CIF
2214 else
2215 posix_lock_type = CIF
2216
2217 if (unlock == 1)
2218 posix_lock_type = CIF
2219
2220 rc = CIFSSMBPosixLock(xid, tc
2221 hash_lo
2222 flock->
2223 NULL, p
2224 goto out;
2225 }
2226 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY *
2227 if (lock) {
2228 struct cifsLockInfo *lock;
2229
2230 lock = cifs_lock_init(flock->
2231 flock->
2232 if (!lock)
2233 return -ENOMEM;
2234
2235 rc = cifs_lock_add_if(cfile,
2236 if (rc < 0) {
2237 kfree(lock);
2238 return rc;
2239 }
2240 if (!rc)
2241 goto out;
2242
2243 /*
2244 * Windows 7 server can delay
2245 * if we set a byte-range loc
2246 * before sending the lock to
2247 * read won't conflict with n
2248 * pagereading.
2249 */
2250 if (!CIFS_CACHE_WRITE(CIFS_I(
2251 CIFS_
2252 cifs_zap_mapping(inod
2253 cifs_dbg(FYI, "Set no
2254 inode);
2255 CIFS_I(inode)->oplock
2256 }
2257
2258 rc = server->ops->mand_lock(x
2259 t
2260 if (rc) {
2261 kfree(lock);
2262 return rc;
2263 }
2264
2265 cifs_lock_add(cfile, lock);
2266 } else if (unlock)
2267 rc = server->ops->mand_unlock
2268
2269 out:
2270 if ((flock->c.flc_flags & FL_POSIX) |
2271 /*
2272 * If this is a request to re
2273 * are closing the file, it d
2274 * unlocking failed as both c
2275 * remove the lock on file cl
2276 */
2277 if (rc) {
2278 cifs_dbg(VFS, "%s fai
2279 if (!(flock->c.flc_fl
2280 return rc;
2281 }
2282 rc = locks_lock_file_wait(fil
2283 }
2284 return rc;
2285 }
2286
2287 int cifs_flock(struct file *file, int cmd, st
2288 {
2289 int rc, xid;
2290 int lock = 0, unlock = 0;
2291 bool wait_flag = false;
2292 bool posix_lck = false;
2293 struct cifs_sb_info *cifs_sb;
2294 struct cifs_tcon *tcon;
2295 struct cifsFileInfo *cfile;
2296 __u32 type;
2297
2298 xid = get_xid();
2299
2300 if (!(fl->c.flc_flags & FL_FLOCK)) {
2301 rc = -ENOLCK;
2302 free_xid(xid);
2303 return rc;
2304 }
2305
2306 cfile = (struct cifsFileInfo *)file->
2307 tcon = tlink_tcon(cfile->tlink);
2308
2309 cifs_read_flock(fl, &type, &lock, &un
2310 tcon->ses->server);
2311 cifs_sb = CIFS_FILE_SB(file);
2312
2313 if (cap_unix(tcon->ses) &&
2314 (CIFS_UNIX_FCNTL_CAP & le64_to_cp
2315 ((cifs_sb->mnt_cifs_flags & CIFS_
2316 posix_lck = true;
2317
2318 if (!lock && !unlock) {
2319 /*
2320 * if no lock or unlock then
2321 * know what it is
2322 */
2323 rc = -EOPNOTSUPP;
2324 free_xid(xid);
2325 return rc;
2326 }
2327
2328 rc = cifs_setlk(file, fl, type, wait_
2329 xid);
2330 free_xid(xid);
2331 return rc;
2332
2333
2334 }
2335
2336 int cifs_lock(struct file *file, int cmd, str
2337 {
2338 int rc, xid;
2339 int lock = 0, unlock = 0;
2340 bool wait_flag = false;
2341 bool posix_lck = false;
2342 struct cifs_sb_info *cifs_sb;
2343 struct cifs_tcon *tcon;
2344 struct cifsFileInfo *cfile;
2345 __u32 type;
2346
2347 rc = -EACCES;
2348 xid = get_xid();
2349
2350 cifs_dbg(FYI, "%s: %pD2 cmd=0x%x type
2351 flock->c.flc_flags, flock->c
2352 (long long)flock->fl_start,
2353 (long long)flock->fl_end);
2354
2355 cfile = (struct cifsFileInfo *)file->
2356 tcon = tlink_tcon(cfile->tlink);
2357
2358 cifs_read_flock(flock, &type, &lock,
2359 tcon->ses->server);
2360 cifs_sb = CIFS_FILE_SB(file);
2361 set_bit(CIFS_INO_CLOSE_ON_LOCK, &CIFS
2362
2363 if (cap_unix(tcon->ses) &&
2364 (CIFS_UNIX_FCNTL_CAP & le64_to_cp
2365 ((cifs_sb->mnt_cifs_flags & CIFS_
2366 posix_lck = true;
2367 /*
2368 * BB add code here to normalize offs
2369 * negative length which we can not a
2370 */
2371 if (IS_GETLK(cmd)) {
2372 rc = cifs_getlk(file, flock,
2373 free_xid(xid);
2374 return rc;
2375 }
2376
2377 if (!lock && !unlock) {
2378 /*
2379 * if no lock or unlock then
2380 * know what it is
2381 */
2382 free_xid(xid);
2383 return -EOPNOTSUPP;
2384 }
2385
2386 rc = cifs_setlk(file, flock, type, wa
2387 xid);
2388 free_xid(xid);
2389 return rc;
2390 }
2391
2392 void cifs_write_subrequest_terminated(struct
2393 bool wa
2394 {
2395 struct netfs_io_request *wreq = wdata
2396 struct netfs_inode *ictx = netfs_inod
2397 loff_t wrend;
2398
2399 if (result > 0) {
2400 wrend = wdata->subreq.start +
2401
2402 if (wrend > ictx->zero_point
2403 (wdata->rreq->origin == N
2404 wdata->rreq->origin == N
2405 ictx->zero_point = wr
2406 if (wrend > ictx->remote_i_si
2407 netfs_resize_file(ict
2408 }
2409
2410 netfs_write_subrequest_terminated(&wd
2411 }
2412
2413 struct cifsFileInfo *find_readable_file(struc
2414 bool
2415 {
2416 struct cifsFileInfo *open_file = NULL
2417 struct cifs_sb_info *cifs_sb = CIFS_S
2418
2419 /* only filter by fsuid on multiuser
2420 if (!(cifs_sb->mnt_cifs_flags & CIFS_
2421 fsuid_only = false;
2422
2423 spin_lock(&cifs_inode->open_file_lock
2424 /* we could simply get the first_list
2425 are always at the end of the list
2426 have a close pending, we go throug
2427 list_for_each_entry(open_file, &cifs_
2428 if (fsuid_only && !uid_eq(ope
2429 continue;
2430 if (OPEN_FMODE(open_file->f_f
2431 if ((!open_file->inva
2432 /* found a go
2433 /* lock it so
2434 cifsFileInfo_
2435 spin_unlock(&
2436 return open_f
2437 } /* else might as we
2438 another, or simp
2439 again rather tha
2440 } else /* write only file */
2441 break; /* write only
2442 }
2443 spin_unlock(&cifs_inode->open_file_lo
2444 return NULL;
2445 }
2446
2447 /* Return -EBADF if no handle is found and ge
2448 int
2449 cifs_get_writable_file(struct cifsInodeInfo *
2450 struct cifsFileInfo **
2451 {
2452 struct cifsFileInfo *open_file, *inv_
2453 struct cifs_sb_info *cifs_sb;
2454 bool any_available = false;
2455 int rc = -EBADF;
2456 unsigned int refind = 0;
2457 bool fsuid_only = flags & FIND_WR_FSU
2458 bool with_delete = flags & FIND_WR_WI
2459 *ret_file = NULL;
2460
2461 /*
2462 * Having a null inode here (because
2463 * the VFS or MM) should not happen b
2464 * to it being zero) during stress te
2465 */
2466
2467 if (cifs_inode == NULL) {
2468 cifs_dbg(VFS, "Null inode pas
2469 dump_stack();
2470 return rc;
2471 }
2472
2473 cifs_sb = CIFS_SB(cifs_inode->netfs.i
2474
2475 /* only filter by fsuid on multiuser
2476 if (!(cifs_sb->mnt_cifs_flags & CIFS_
2477 fsuid_only = false;
2478
2479 spin_lock(&cifs_inode->open_file_lock
2480 refind_writable:
2481 if (refind > MAX_REOPEN_ATT) {
2482 spin_unlock(&cifs_inode->open
2483 return rc;
2484 }
2485 list_for_each_entry(open_file, &cifs_
2486 if (!any_available && open_fi
2487 continue;
2488 if (fsuid_only && !uid_eq(ope
2489 continue;
2490 if (with_delete && !(open_fil
2491 continue;
2492 if (OPEN_FMODE(open_file->f_f
2493 if (!open_file->inval
2494 /* found a go
2495 cifsFileInfo_
2496 spin_unlock(&
2497 *ret_file = o
2498 return 0;
2499 } else {
2500 if (!inv_file
2501 inv_f
2502 }
2503 }
2504 }
2505 /* couldn't find usable FH with same
2506 if (!any_available) {
2507 any_available = true;
2508 goto refind_writable;
2509 }
2510
2511 if (inv_file) {
2512 any_available = false;
2513 cifsFileInfo_get(inv_file);
2514 }
2515
2516 spin_unlock(&cifs_inode->open_file_lo
2517
2518 if (inv_file) {
2519 rc = cifs_reopen_file(inv_fil
2520 if (!rc) {
2521 *ret_file = inv_file;
2522 return 0;
2523 }
2524
2525 spin_lock(&cifs_inode->open_f
2526 list_move_tail(&inv_file->fli
2527 spin_unlock(&cifs_inode->open
2528 cifsFileInfo_put(inv_file);
2529 ++refind;
2530 inv_file = NULL;
2531 spin_lock(&cifs_inode->open_f
2532 goto refind_writable;
2533 }
2534
2535 return rc;
2536 }
2537
2538 struct cifsFileInfo *
2539 find_writable_file(struct cifsInodeInfo *cifs
2540 {
2541 struct cifsFileInfo *cfile;
2542 int rc;
2543
2544 rc = cifs_get_writable_file(cifs_inod
2545 if (rc)
2546 cifs_dbg(FYI, "Couldn't find
2547
2548 return cfile;
2549 }
2550
2551 int
2552 cifs_get_writable_path(struct cifs_tcon *tcon
2553 int flags,
2554 struct cifsFileInfo **
2555 {
2556 struct cifsFileInfo *cfile;
2557 void *page = alloc_dentry_path();
2558
2559 *ret_file = NULL;
2560
2561 spin_lock(&tcon->open_file_lock);
2562 list_for_each_entry(cfile, &tcon->ope
2563 struct cifsInodeInfo *cinode;
2564 const char *full_path = build
2565 if (IS_ERR(full_path)) {
2566 spin_unlock(&tcon->op
2567 free_dentry_path(page
2568 return PTR_ERR(full_p
2569 }
2570 if (strcmp(full_path, name))
2571 continue;
2572
2573 cinode = CIFS_I(d_inode(cfile
2574 spin_unlock(&tcon->open_file_
2575 free_dentry_path(page);
2576 return cifs_get_writable_file
2577 }
2578
2579 spin_unlock(&tcon->open_file_lock);
2580 free_dentry_path(page);
2581 return -ENOENT;
2582 }
2583
2584 int
2585 cifs_get_readable_path(struct cifs_tcon *tcon
2586 struct cifsFileInfo **
2587 {
2588 struct cifsFileInfo *cfile;
2589 void *page = alloc_dentry_path();
2590
2591 *ret_file = NULL;
2592
2593 spin_lock(&tcon->open_file_lock);
2594 list_for_each_entry(cfile, &tcon->ope
2595 struct cifsInodeInfo *cinode;
2596 const char *full_path = build
2597 if (IS_ERR(full_path)) {
2598 spin_unlock(&tcon->op
2599 free_dentry_path(page
2600 return PTR_ERR(full_p
2601 }
2602 if (strcmp(full_path, name))
2603 continue;
2604
2605 cinode = CIFS_I(d_inode(cfile
2606 spin_unlock(&tcon->open_file_
2607 free_dentry_path(page);
2608 *ret_file = find_readable_fil
2609 return *ret_file ? 0 : -ENOEN
2610 }
2611
2612 spin_unlock(&tcon->open_file_lock);
2613 free_dentry_path(page);
2614 return -ENOENT;
2615 }
2616
2617 /*
2618 * Flush data on a strict file.
2619 */
2620 int cifs_strict_fsync(struct file *file, loff
2621 int datasync)
2622 {
2623 unsigned int xid;
2624 int rc = 0;
2625 struct cifs_tcon *tcon;
2626 struct TCP_Server_Info *server;
2627 struct cifsFileInfo *smbfile = file->
2628 struct inode *inode = file_inode(file
2629 struct cifs_sb_info *cifs_sb = CIFS_S
2630
2631 rc = file_write_and_wait_range(file,
2632 if (rc) {
2633 trace_cifs_fsync_err(inode->i
2634 return rc;
2635 }
2636
2637 xid = get_xid();
2638
2639 cifs_dbg(FYI, "Sync file - name: %pD
2640 file, datasync);
2641
2642 if (!CIFS_CACHE_READ(CIFS_I(inode)))
2643 rc = cifs_zap_mapping(inode);
2644 if (rc) {
2645 cifs_dbg(FYI, "rc: %d
2646 rc = 0; /* don't care
2647 }
2648 }
2649
2650 tcon = tlink_tcon(smbfile->tlink);
2651 if (!(cifs_sb->mnt_cifs_flags & CIFS_
2652 server = tcon->ses->server;
2653 if (server->ops->flush == NUL
2654 rc = -ENOSYS;
2655 goto strict_fsync_exi
2656 }
2657
2658 if ((OPEN_FMODE(smbfile->f_fl
2659 smbfile = find_writab
2660 if (smbfile) {
2661 rc = server->
2662 cifsFileInfo_
2663 } else
2664 cifs_dbg(FYI,
2665 } else
2666 rc = server->ops->flu
2667 }
2668
2669 strict_fsync_exit:
2670 free_xid(xid);
2671 return rc;
2672 }
2673
2674 /*
2675 * Flush data on a non-strict data.
2676 */
2677 int cifs_fsync(struct file *file, loff_t star
2678 {
2679 unsigned int xid;
2680 int rc = 0;
2681 struct cifs_tcon *tcon;
2682 struct TCP_Server_Info *server;
2683 struct cifsFileInfo *smbfile = file->
2684 struct inode *inode = file_inode(file
2685 struct cifs_sb_info *cifs_sb = CIFS_F
2686
2687 rc = file_write_and_wait_range(file,
2688 if (rc) {
2689 trace_cifs_fsync_err(file_ino
2690 return rc;
2691 }
2692
2693 xid = get_xid();
2694
2695 cifs_dbg(FYI, "Sync file - name: %pD
2696 file, datasync);
2697
2698 tcon = tlink_tcon(smbfile->tlink);
2699 if (!(cifs_sb->mnt_cifs_flags & CIFS_
2700 server = tcon->ses->server;
2701 if (server->ops->flush == NUL
2702 rc = -ENOSYS;
2703 goto fsync_exit;
2704 }
2705
2706 if ((OPEN_FMODE(smbfile->f_fl
2707 smbfile = find_writab
2708 if (smbfile) {
2709 rc = server->
2710 cifsFileInfo_
2711 } else
2712 cifs_dbg(FYI,
2713 } else
2714 rc = server->ops->flu
2715 }
2716
2717 fsync_exit:
2718 free_xid(xid);
2719 return rc;
2720 }
2721
2722 /*
2723 * As file closes, flush all cached write dat
2724 * for write behind errors.
2725 */
2726 int cifs_flush(struct file *file, fl_owner_t
2727 {
2728 struct inode *inode = file_inode(file
2729 int rc = 0;
2730
2731 if (file->f_mode & FMODE_WRITE)
2732 rc = filemap_write_and_wait(i
2733
2734 cifs_dbg(FYI, "Flush inode %p file %p
2735 if (rc) {
2736 /* get more nuanced writeback
2737 rc = filemap_check_wb_err(fil
2738 trace_cifs_flush_err(inode->i
2739 }
2740 return rc;
2741 }
2742
2743 static ssize_t
2744 cifs_writev(struct kiocb *iocb, struct iov_it
2745 {
2746 struct file *file = iocb->ki_filp;
2747 struct cifsFileInfo *cfile = (struct
2748 struct inode *inode = file->f_mapping
2749 struct cifsInodeInfo *cinode = CIFS_I
2750 struct TCP_Server_Info *server = tlin
2751 struct cifs_sb_info *cifs_sb = CIFS_S
2752 ssize_t rc;
2753
2754 rc = netfs_start_io_write(inode);
2755 if (rc < 0)
2756 return rc;
2757
2758 /*
2759 * We need to hold the sem to be sure
2760 * with a brlock that prevents writin
2761 */
2762 down_read(&cinode->lock_sem);
2763
2764 rc = generic_write_checks(iocb, from)
2765 if (rc <= 0)
2766 goto out;
2767
2768 if ((cifs_sb->mnt_cifs_flags & CIFS_M
2769 (cifs_find_lock_conflict(cfile, i
2770 server->
2771 NULL, CI
2772 rc = -EACCES;
2773 goto out;
2774 }
2775
2776 rc = netfs_buffered_write_iter_locked
2777
2778 out:
2779 up_read(&cinode->lock_sem);
2780 netfs_end_io_write(inode);
2781 if (rc > 0)
2782 rc = generic_write_sync(iocb,
2783 return rc;
2784 }
2785
2786 ssize_t
2787 cifs_strict_writev(struct kiocb *iocb, struct
2788 {
2789 struct inode *inode = file_inode(iocb
2790 struct cifsInodeInfo *cinode = CIFS_I
2791 struct cifs_sb_info *cifs_sb = CIFS_S
2792 struct cifsFileInfo *cfile = (struct
2793
2794 struct cifs_tcon *tcon = tlink_tcon(c
2795 ssize_t written;
2796
2797 written = cifs_get_writer(cinode);
2798 if (written)
2799 return written;
2800
2801 if (CIFS_CACHE_WRITE(cinode)) {
2802 if (cap_unix(tcon->ses) &&
2803 (CIFS_UNIX_FCNTL_CAP & le
2804 ((cifs_sb->mnt_cifs_flags
2805 written = netfs_file_
2806 goto out;
2807 }
2808 written = cifs_writev(iocb, f
2809 goto out;
2810 }
2811 /*
2812 * For non-oplocked files in strict c
2813 * to the server exactly from the pos
2814 * affected pages because it may caus
2815 * these pages but not on the region
2816 */
2817 written = netfs_file_write_iter(iocb,
2818 if (CIFS_CACHE_READ(cinode)) {
2819 /*
2820 * We have read level caching
2821 * request to the server thus
2822 * Zap the cache and set oplo
2823 * reading stale data from th
2824 * operations will read new d
2825 */
2826 cifs_zap_mapping(inode);
2827 cifs_dbg(FYI, "Set Oplock/Lea
2828 inode);
2829 cinode->oplock = 0;
2830 }
2831 out:
2832 cifs_put_writer(cinode);
2833 return written;
2834 }
2835
2836 ssize_t cifs_loose_read_iter(struct kiocb *io
2837 {
2838 ssize_t rc;
2839 struct inode *inode = file_inode(iocb
2840
2841 if (iocb->ki_flags & IOCB_DIRECT)
2842 return netfs_unbuffered_read_
2843
2844 rc = cifs_revalidate_mapping(inode);
2845 if (rc)
2846 return rc;
2847
2848 return netfs_file_read_iter(iocb, ite
2849 }
2850
2851 ssize_t cifs_file_write_iter(struct kiocb *io
2852 {
2853 struct inode *inode = file_inode(iocb
2854 struct cifsInodeInfo *cinode = CIFS_I
2855 ssize_t written;
2856 int rc;
2857
2858 if (iocb->ki_filp->f_flags & O_DIRECT
2859 written = netfs_unbuffered_wr
2860 if (written > 0 && CIFS_CACHE
2861 cifs_zap_mapping(inod
2862 cifs_dbg(FYI,
2863 "Set no oplo
2864 inode);
2865 cinode->oplock = 0;
2866 }
2867 return written;
2868 }
2869
2870 written = cifs_get_writer(cinode);
2871 if (written)
2872 return written;
2873
2874 written = netfs_file_write_iter(iocb,
2875
2876 if (!CIFS_CACHE_WRITE(CIFS_I(inode)))
2877 rc = filemap_fdatawrite(inode
2878 if (rc)
2879 cifs_dbg(FYI, "cifs_f
2880 rc, inode);
2881 }
2882
2883 cifs_put_writer(cinode);
2884 return written;
2885 }
2886
2887 ssize_t
2888 cifs_strict_readv(struct kiocb *iocb, struct
2889 {
2890 struct inode *inode = file_inode(iocb
2891 struct cifsInodeInfo *cinode = CIFS_I
2892 struct cifs_sb_info *cifs_sb = CIFS_S
2893 struct cifsFileInfo *cfile = (struct
2894
2895 struct cifs_tcon *tcon = tlink_tcon(c
2896 int rc = -EACCES;
2897
2898 /*
2899 * In strict cache mode we need to re
2900 * if we don't have level II oplock b
2901 * change - so we can't make a decisi
2902 * And we can also fail with pageread
2903 * on pages affected by this read but
2904 * pos+len-1.
2905 */
2906 if (!CIFS_CACHE_READ(cinode))
2907 return netfs_unbuffered_read_
2908
2909 if ((cifs_sb->mnt_cifs_flags & CIFS_M
2910 if (iocb->ki_flags & IOCB_DIR
2911 return netfs_unbuffer
2912 return netfs_buffered_read_it
2913 }
2914
2915 /*
2916 * We need to hold the sem to be sure
2917 * with a brlock that prevents readin
2918 */
2919 if (iocb->ki_flags & IOCB_DIRECT) {
2920 rc = netfs_start_io_direct(in
2921 if (rc < 0)
2922 goto out;
2923 rc = -EACCES;
2924 down_read(&cinode->lock_sem);
2925 if (!cifs_find_lock_conflict(
2926 cfile, iocb->ki_p
2927 tcon->ses->server
2928 0, NULL, CIFS_REA
2929 rc = netfs_unbuffered
2930 up_read(&cinode->lock_sem);
2931 netfs_end_io_direct(inode);
2932 } else {
2933 rc = netfs_start_io_read(inod
2934 if (rc < 0)
2935 goto out;
2936 rc = -EACCES;
2937 down_read(&cinode->lock_sem);
2938 if (!cifs_find_lock_conflict(
2939 cfile, iocb->ki_p
2940 tcon->ses->server
2941 0, NULL, CIFS_REA
2942 rc = filemap_read(ioc
2943 up_read(&cinode->lock_sem);
2944 netfs_end_io_read(inode);
2945 }
2946 out:
2947 return rc;
2948 }
2949
2950 static vm_fault_t cifs_page_mkwrite(struct vm
2951 {
2952 return netfs_page_mkwrite(vmf, NULL);
2953 }
2954
2955 static const struct vm_operations_struct cifs
2956 .fault = filemap_fault,
2957 .map_pages = filemap_map_pages,
2958 .page_mkwrite = cifs_page_mkwrite,
2959 };
2960
2961 int cifs_file_strict_mmap(struct file *file,
2962 {
2963 int xid, rc = 0;
2964 struct inode *inode = file_inode(file
2965
2966 xid = get_xid();
2967
2968 if (!CIFS_CACHE_READ(CIFS_I(inode)))
2969 rc = cifs_zap_mapping(inode);
2970 if (!rc)
2971 rc = generic_file_mmap(file,
2972 if (!rc)
2973 vma->vm_ops = &cifs_file_vm_o
2974
2975 free_xid(xid);
2976 return rc;
2977 }
2978
2979 int cifs_file_mmap(struct file *file, struct
2980 {
2981 int rc, xid;
2982
2983 xid = get_xid();
2984
2985 rc = cifs_revalidate_file(file);
2986 if (rc)
2987 cifs_dbg(FYI, "Validation pri
2988 rc);
2989 if (!rc)
2990 rc = generic_file_mmap(file,
2991 if (!rc)
2992 vma->vm_ops = &cifs_file_vm_o
2993
2994 free_xid(xid);
2995 return rc;
2996 }
2997
2998 static int is_inode_writable(struct cifsInode
2999 {
3000 struct cifsFileInfo *open_file;
3001
3002 spin_lock(&cifs_inode->open_file_lock
3003 list_for_each_entry(open_file, &cifs_
3004 if (OPEN_FMODE(open_file->f_f
3005 spin_unlock(&cifs_ino
3006 return 1;
3007 }
3008 }
3009 spin_unlock(&cifs_inode->open_file_lo
3010 return 0;
3011 }
3012
3013 /* We do not want to update the file size fro
3014 open for write - to avoid races with write
3015 the file - in the future we could consider
3016 refreshing the inode only on increases in
3017 but this is tricky to do without racing wi
3018 page caching in the current Linux kernel d
3019 bool is_size_safe_to_change(struct cifsInodeI
3020 bool from_readdir
3021 {
3022 if (!cifsInode)
3023 return true;
3024
3025 if (is_inode_writable(cifsInode) ||
3026 ((cifsInode->oplock & CIFS_CA
3027 /* This inode is open for wri
3028 struct cifs_sb_info *cifs_sb;
3029
3030 cifs_sb = CIFS_SB(cifsInode->
3031 if (cifs_sb->mnt_cifs_flags &
3032 /* since no page cach
3033 we can change size sa
3034 return true;
3035 }
3036
3037 if (i_size_read(&cifsInode->n
3038 return true;
3039
3040 return false;
3041 } else
3042 return true;
3043 }
3044
3045 void cifs_oplock_break(struct work_struct *wo
3046 {
3047 struct cifsFileInfo *cfile = containe
3048
3049 struct inode *inode = d_inode(cfile->
3050 struct cifs_sb_info *cifs_sb = CIFS_S
3051 struct cifsInodeInfo *cinode = CIFS_I
3052 struct cifs_tcon *tcon;
3053 struct TCP_Server_Info *server;
3054 struct tcon_link *tlink;
3055 int rc = 0;
3056 bool purge_cache = false, oplock_brea
3057 __u64 persistent_fid, volatile_fid;
3058 __u16 net_fid;
3059
3060 wait_on_bit(&cinode->flags, CIFS_INOD
3061 TASK_UNINTERRUPTIBLE)
3062
3063 tlink = cifs_sb_tlink(cifs_sb);
3064 if (IS_ERR(tlink))
3065 goto out;
3066 tcon = tlink_tcon(tlink);
3067 server = tcon->ses->server;
3068
3069 server->ops->downgrade_oplock(server,
3070 cfile->
3071
3072 if (!CIFS_CACHE_WRITE(cinode) && CIFS
3073
3074 cifs_dbg(FYI, "Reset oplock t
3075 inode);
3076 cinode->oplock = 0;
3077 }
3078
3079 if (inode && S_ISREG(inode->i_mode))
3080 if (CIFS_CACHE_READ(cinode))
3081 break_lease(inode, O_
3082 else
3083 break_lease(inode, O_
3084 rc = filemap_fdatawrite(inode
3085 if (!CIFS_CACHE_READ(cinode)
3086 rc = filemap_fdatawai
3087 mapping_set_error(ino
3088 cifs_zap_mapping(inod
3089 }
3090 cifs_dbg(FYI, "Oplock flush i
3091 if (CIFS_CACHE_WRITE(cinode))
3092 goto oplock_break_ack
3093 }
3094
3095 rc = cifs_push_locks(cfile);
3096 if (rc)
3097 cifs_dbg(VFS, "Push locks rc
3098
3099 oplock_break_ack:
3100 /*
3101 * When oplock break is received and
3102 * file handles but cached, then sche
3103 * So, new open will not use cached h
3104 */
3105
3106 if (!CIFS_CACHE_HANDLE(cinode) && !li
3107 cifs_close_deferred_file(cino
3108
3109 persistent_fid = cfile->fid.persisten
3110 volatile_fid = cfile->fid.volatile_fi
3111 net_fid = cfile->fid.netfid;
3112 oplock_break_cancelled = cfile->oploc
3113
3114 _cifsFileInfo_put(cfile, false /* do
3115 /*
3116 * MS-SMB2 3.2.5.19.1 and 3.2.5.19.2
3117 * an acknowledgment to be sent when
3118 */
3119 spin_lock(&cinode->open_file_lock);
3120 /* check list empty since can race wi
3121 if (!oplock_break_cancelled && !list_
3122 spin_unlock(&cinode->open_fil
3123 rc = server->ops->oplock_resp
3124
3125 cifs_dbg(FYI, "Oplock release
3126 } else
3127 spin_unlock(&cinode->open_fil
3128
3129 cifs_put_tlink(tlink);
3130 out:
3131 cifs_done_oplock_break(cinode);
3132 }
3133
3134 static int cifs_swap_activate(struct swap_inf
3135 struct file *sw
3136 {
3137 struct cifsFileInfo *cfile = swap_fil
3138 struct inode *inode = swap_file->f_ma
3139 unsigned long blocks;
3140 long long isize;
3141
3142 cifs_dbg(FYI, "swap activate\n");
3143
3144 if (!swap_file->f_mapping->a_ops->swa
3145 /* Cannot support swap */
3146 return -EINVAL;
3147
3148 spin_lock(&inode->i_lock);
3149 blocks = inode->i_blocks;
3150 isize = inode->i_size;
3151 spin_unlock(&inode->i_lock);
3152 if (blocks*512 < isize) {
3153 pr_warn("swap activate: swapf
3154 return -EINVAL;
3155 }
3156 *span = sis->pages;
3157
3158 pr_warn_once("Swap support over SMB3
3159
3160 /*
3161 * TODO: consider adding ACL (or docu
3162 * users (on this or other systems) f
3163 */
3164
3165
3166 /* TODO: add sk_set_memalloc(inet) or
3167
3168 if (cfile)
3169 cfile->swapfile = true;
3170 /*
3171 * TODO: Since file already open, we
3172 * but we could add call to grab a by
3173 * from reading or writing the file
3174 */
3175
3176 sis->flags |= SWP_FS_OPS;
3177 return add_swap_extent(sis, 0, sis->m
3178 }
3179
3180 static void cifs_swap_deactivate(struct file
3181 {
3182 struct cifsFileInfo *cfile = file->pr
3183
3184 cifs_dbg(FYI, "swap deactivate\n");
3185
3186 /* TODO: undo sk_set_memalloc(inet) w
3187
3188 if (cfile)
3189 cfile->swapfile = false;
3190
3191 /* do we need to unpin (or unlock) th
3192 }
3193
3194 /**
3195 * cifs_swap_rw - SMB3 address space operatio
3196 * @iocb: target I/O control block
3197 * @iter: I/O buffer
3198 *
3199 * Perform IO to the swap-file. This is much
3200 */
3201 static int cifs_swap_rw(struct kiocb *iocb, s
3202 {
3203 ssize_t ret;
3204
3205 if (iov_iter_rw(iter) == READ)
3206 ret = netfs_unbuffered_read_i
3207 else
3208 ret = netfs_unbuffered_write_
3209 if (ret < 0)
3210 return ret;
3211 return 0;
3212 }
3213
3214 const struct address_space_operations cifs_ad
3215 .read_folio = netfs_read_folio,
3216 .readahead = netfs_readahead,
3217 .writepages = netfs_writepages,
3218 .dirty_folio = netfs_dirty_folio,
3219 .release_folio = netfs_release_folio
3220 .direct_IO = noop_direct_IO,
3221 .invalidate_folio = netfs_invalidate_
3222 .migrate_folio = filemap_migrate_fol
3223 /*
3224 * TODO: investigate and if useful we
3225 * helper if needed
3226 */
3227 .swap_activate = cifs_swap_activate,
3228 .swap_deactivate = cifs_swap_deactiva
3229 .swap_rw = cifs_swap_rw,
3230 };
3231
3232 /*
3233 * cifs_readahead requires the server to supp
3234 * contain the header plus one complete page
3235 * to leave cifs_readahead out of the address
3236 */
3237 const struct address_space_operations cifs_ad
3238 .read_folio = netfs_read_folio,
3239 .writepages = netfs_writepages,
3240 .dirty_folio = netfs_dirty_folio,
3241 .release_folio = netfs_release_folio
3242 .invalidate_folio = netfs_invalidate_
3243 .migrate_folio = filemap_migrate_fol
3244 };
3245
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.