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