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