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