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