]> 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 'io_uring-20190323' of git://git.kernel.dk/linux-block
[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) {
1649 /*
1650 * If this is a request to remove all locks because we
1651 * are closing the file, it doesn't matter if the
1652 * unlocking failed as both cifs.ko and the SMB server
1653 * remove the lock on file close
1654 */
1655 if (rc) {
1656 cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc);
1657 if (!(flock->fl_flags & FL_CLOSE))
1658 return rc;
1659 }
1660 rc = locks_lock_file_wait(file, flock);
1661 }
1662 return rc;
1663 }
1664
1665 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1666 {
1667 int rc, xid;
1668 int lock = 0, unlock = 0;
1669 bool wait_flag = false;
1670 bool posix_lck = false;
1671 struct cifs_sb_info *cifs_sb;
1672 struct cifs_tcon *tcon;
1673 struct cifsInodeInfo *cinode;
1674 struct cifsFileInfo *cfile;
1675 __u16 netfid;
1676 __u32 type;
1677
1678 rc = -EACCES;
1679 xid = get_xid();
1680
1681 cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1682 cmd, flock->fl_flags, flock->fl_type,
1683 flock->fl_start, flock->fl_end);
1684
1685 cfile = (struct cifsFileInfo *)file->private_data;
1686 tcon = tlink_tcon(cfile->tlink);
1687
1688 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1689 tcon->ses->server);
1690 cifs_sb = CIFS_FILE_SB(file);
1691 netfid = cfile->fid.netfid;
1692 cinode = CIFS_I(file_inode(file));
1693
1694 if (cap_unix(tcon->ses) &&
1695 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1696 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1697 posix_lck = true;
1698 /*
1699 * BB add code here to normalize offset and length to account for
1700 * negative length which we can not accept over the wire.
1701 */
1702 if (IS_GETLK(cmd)) {
1703 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1704 free_xid(xid);
1705 return rc;
1706 }
1707
1708 if (!lock && !unlock) {
1709 /*
1710 * if no lock or unlock then nothing to do since we do not
1711 * know what it is
1712 */
1713 free_xid(xid);
1714 return -EOPNOTSUPP;
1715 }
1716
1717 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1718 xid);
1719 free_xid(xid);
1720 return rc;
1721 }
1722
1723 /*
1724 * update the file size (if needed) after a write. Should be called with
1725 * the inode->i_lock held
1726 */
1727 void
1728 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1729 unsigned int bytes_written)
1730 {
1731 loff_t end_of_write = offset + bytes_written;
1732
1733 if (end_of_write > cifsi->server_eof)
1734 cifsi->server_eof = end_of_write;
1735 }
1736
1737 static ssize_t
1738 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1739 size_t write_size, loff_t *offset)
1740 {
1741 int rc = 0;
1742 unsigned int bytes_written = 0;
1743 unsigned int total_written;
1744 struct cifs_sb_info *cifs_sb;
1745 struct cifs_tcon *tcon;
1746 struct TCP_Server_Info *server;
1747 unsigned int xid;
1748 struct dentry *dentry = open_file->dentry;
1749 struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1750 struct cifs_io_parms io_parms;
1751
1752 cifs_sb = CIFS_SB(dentry->d_sb);
1753
1754 cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
1755 write_size, *offset, dentry);
1756
1757 tcon = tlink_tcon(open_file->tlink);
1758 server = tcon->ses->server;
1759
1760 if (!server->ops->sync_write)
1761 return -ENOSYS;
1762
1763 xid = get_xid();
1764
1765 for (total_written = 0; write_size > total_written;
1766 total_written += bytes_written) {
1767 rc = -EAGAIN;
1768 while (rc == -EAGAIN) {
1769 struct kvec iov[2];
1770 unsigned int len;
1771
1772 if (open_file->invalidHandle) {
1773 /* we could deadlock if we called
1774 filemap_fdatawait from here so tell
1775 reopen_file not to flush data to
1776 server now */
1777 rc = cifs_reopen_file(open_file, false);
1778 if (rc != 0)
1779 break;
1780 }
1781
1782 len = min(server->ops->wp_retry_size(d_inode(dentry)),
1783 (unsigned int)write_size - total_written);
1784 /* iov[0] is reserved for smb header */
1785 iov[1].iov_base = (char *)write_data + total_written;
1786 iov[1].iov_len = len;
1787 io_parms.pid = pid;
1788 io_parms.tcon = tcon;
1789 io_parms.offset = *offset;
1790 io_parms.length = len;
1791 rc = server->ops->sync_write(xid, &open_file->fid,
1792 &io_parms, &bytes_written, iov, 1);
1793 }
1794 if (rc || (bytes_written == 0)) {
1795 if (total_written)
1796 break;
1797 else {
1798 free_xid(xid);
1799 return rc;
1800 }
1801 } else {
1802 spin_lock(&d_inode(dentry)->i_lock);
1803 cifs_update_eof(cifsi, *offset, bytes_written);
1804 spin_unlock(&d_inode(dentry)->i_lock);
1805 *offset += bytes_written;
1806 }
1807 }
1808
1809 cifs_stats_bytes_written(tcon, total_written);
1810
1811 if (total_written > 0) {
1812 spin_lock(&d_inode(dentry)->i_lock);
1813 if (*offset > d_inode(dentry)->i_size)
1814 i_size_write(d_inode(dentry), *offset);
1815 spin_unlock(&d_inode(dentry)->i_lock);
1816 }
1817 mark_inode_dirty_sync(d_inode(dentry));
1818 free_xid(xid);
1819 return total_written;
1820 }
1821
1822 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1823 bool fsuid_only)
1824 {
1825 struct cifsFileInfo *open_file = NULL;
1826 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1827 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1828
1829 /* only filter by fsuid on multiuser mounts */
1830 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1831 fsuid_only = false;
1832
1833 spin_lock(&tcon->open_file_lock);
1834 /* we could simply get the first_list_entry since write-only entries
1835 are always at the end of the list but since the first entry might
1836 have a close pending, we go through the whole list */
1837 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1838 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1839 continue;
1840 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1841 if (!open_file->invalidHandle) {
1842 /* found a good file */
1843 /* lock it so it will not be closed on us */
1844 cifsFileInfo_get(open_file);
1845 spin_unlock(&tcon->open_file_lock);
1846 return open_file;
1847 } /* else might as well continue, and look for
1848 another, or simply have the caller reopen it
1849 again rather than trying to fix this handle */
1850 } else /* write only file */
1851 break; /* write only files are last so must be done */
1852 }
1853 spin_unlock(&tcon->open_file_lock);
1854 return NULL;
1855 }
1856
1857 /* Return -EBADF if no handle is found and general rc otherwise */
1858 int
1859 cifs_get_writable_file(struct cifsInodeInfo *cifs_inode, bool fsuid_only,
1860 struct cifsFileInfo **ret_file)
1861 {
1862 struct cifsFileInfo *open_file, *inv_file = NULL;
1863 struct cifs_sb_info *cifs_sb;
1864 struct cifs_tcon *tcon;
1865 bool any_available = false;
1866 int rc = -EBADF;
1867 unsigned int refind = 0;
1868
1869 *ret_file = NULL;
1870
1871 /*
1872 * Having a null inode here (because mapping->host was set to zero by
1873 * the VFS or MM) should not happen but we had reports of on oops (due
1874 * to it being zero) during stress testcases so we need to check for it
1875 */
1876
1877 if (cifs_inode == NULL) {
1878 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1879 dump_stack();
1880 return rc;
1881 }
1882
1883 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1884 tcon = cifs_sb_master_tcon(cifs_sb);
1885
1886 /* only filter by fsuid on multiuser mounts */
1887 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1888 fsuid_only = false;
1889
1890 spin_lock(&tcon->open_file_lock);
1891 refind_writable:
1892 if (refind > MAX_REOPEN_ATT) {
1893 spin_unlock(&tcon->open_file_lock);
1894 return rc;
1895 }
1896 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1897 if (!any_available && open_file->pid != current->tgid)
1898 continue;
1899 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1900 continue;
1901 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1902 if (!open_file->invalidHandle) {
1903 /* found a good writable file */
1904 cifsFileInfo_get(open_file);
1905 spin_unlock(&tcon->open_file_lock);
1906 *ret_file = open_file;
1907 return 0;
1908 } else {
1909 if (!inv_file)
1910 inv_file = open_file;
1911 }
1912 }
1913 }
1914 /* couldn't find useable FH with same pid, try any available */
1915 if (!any_available) {
1916 any_available = true;
1917 goto refind_writable;
1918 }
1919
1920 if (inv_file) {
1921 any_available = false;
1922 cifsFileInfo_get(inv_file);
1923 }
1924
1925 spin_unlock(&tcon->open_file_lock);
1926
1927 if (inv_file) {
1928 rc = cifs_reopen_file(inv_file, false);
1929 if (!rc) {
1930 *ret_file = inv_file;
1931 return 0;
1932 }
1933
1934 spin_lock(&tcon->open_file_lock);
1935 list_move_tail(&inv_file->flist, &cifs_inode->openFileList);
1936 spin_unlock(&tcon->open_file_lock);
1937 cifsFileInfo_put(inv_file);
1938 ++refind;
1939 inv_file = NULL;
1940 spin_lock(&tcon->open_file_lock);
1941 goto refind_writable;
1942 }
1943
1944 return rc;
1945 }
1946
1947 struct cifsFileInfo *
1948 find_writable_file(struct cifsInodeInfo *cifs_inode, bool fsuid_only)
1949 {
1950 struct cifsFileInfo *cfile;
1951 int rc;
1952
1953 rc = cifs_get_writable_file(cifs_inode, fsuid_only, &cfile);
1954 if (rc)
1955 cifs_dbg(FYI, "couldn't find writable handle rc=%d", rc);
1956
1957 return cfile;
1958 }
1959
1960 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1961 {
1962 struct address_space *mapping = page->mapping;
1963 loff_t offset = (loff_t)page->index << PAGE_SHIFT;
1964 char *write_data;
1965 int rc = -EFAULT;
1966 int bytes_written = 0;
1967 struct inode *inode;
1968 struct cifsFileInfo *open_file;
1969
1970 if (!mapping || !mapping->host)
1971 return -EFAULT;
1972
1973 inode = page->mapping->host;
1974
1975 offset += (loff_t)from;
1976 write_data = kmap(page);
1977 write_data += from;
1978
1979 if ((to > PAGE_SIZE) || (from > to)) {
1980 kunmap(page);
1981 return -EIO;
1982 }
1983
1984 /* racing with truncate? */
1985 if (offset > mapping->host->i_size) {
1986 kunmap(page);
1987 return 0; /* don't care */
1988 }
1989
1990 /* check to make sure that we are not extending the file */
1991 if (mapping->host->i_size - offset < (loff_t)to)
1992 to = (unsigned)(mapping->host->i_size - offset);
1993
1994 rc = cifs_get_writable_file(CIFS_I(mapping->host), false, &open_file);
1995 if (!rc) {
1996 bytes_written = cifs_write(open_file, open_file->pid,
1997 write_data, to - from, &offset);
1998 cifsFileInfo_put(open_file);
1999 /* Does mm or vfs already set times? */
2000 inode->i_atime = inode->i_mtime = current_time(inode);
2001 if ((bytes_written > 0) && (offset))
2002 rc = 0;
2003 else if (bytes_written < 0)
2004 rc = bytes_written;
2005 else
2006 rc = -EFAULT;
2007 } else {
2008 cifs_dbg(FYI, "No writable handle for write page rc=%d\n", rc);
2009 if (!is_retryable_error(rc))
2010 rc = -EIO;
2011 }
2012
2013 kunmap(page);
2014 return rc;
2015 }
2016
2017 static struct cifs_writedata *
2018 wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
2019 pgoff_t end, pgoff_t *index,
2020 unsigned int *found_pages)
2021 {
2022 struct cifs_writedata *wdata;
2023
2024 wdata = cifs_writedata_alloc((unsigned int)tofind,
2025 cifs_writev_complete);
2026 if (!wdata)
2027 return NULL;
2028
2029 *found_pages = find_get_pages_range_tag(mapping, index, end,
2030 PAGECACHE_TAG_DIRTY, tofind, wdata->pages);
2031 return wdata;
2032 }
2033
2034 static unsigned int
2035 wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
2036 struct address_space *mapping,
2037 struct writeback_control *wbc,
2038 pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
2039 {
2040 unsigned int nr_pages = 0, i;
2041 struct page *page;
2042
2043 for (i = 0; i < found_pages; i++) {
2044 page = wdata->pages[i];
2045 /*
2046 * At this point we hold neither the i_pages lock nor the
2047 * page lock: the page may be truncated or invalidated
2048 * (changing page->mapping to NULL), or even swizzled
2049 * back from swapper_space to tmpfs file mapping
2050 */
2051
2052 if (nr_pages == 0)
2053 lock_page(page);
2054 else if (!trylock_page(page))
2055 break;
2056
2057 if (unlikely(page->mapping != mapping)) {
2058 unlock_page(page);
2059 break;
2060 }
2061
2062 if (!wbc->range_cyclic && page->index > end) {
2063 *done = true;
2064 unlock_page(page);
2065 break;
2066 }
2067
2068 if (*next && (page->index != *next)) {
2069 /* Not next consecutive page */
2070 unlock_page(page);
2071 break;
2072 }
2073
2074 if (wbc->sync_mode != WB_SYNC_NONE)
2075 wait_on_page_writeback(page);
2076
2077 if (PageWriteback(page) ||
2078 !clear_page_dirty_for_io(page)) {
2079 unlock_page(page);
2080 break;
2081 }
2082
2083 /*
2084 * This actually clears the dirty bit in the radix tree.
2085 * See cifs_writepage() for more commentary.
2086 */
2087 set_page_writeback(page);
2088 if (page_offset(page) >= i_size_read(mapping->host)) {
2089 *done = true;
2090 unlock_page(page);
2091 end_page_writeback(page);
2092 break;
2093 }
2094
2095 wdata->pages[i] = page;
2096 *next = page->index + 1;
2097 ++nr_pages;
2098 }
2099
2100 /* reset index to refind any pages skipped */
2101 if (nr_pages == 0)
2102 *index = wdata->pages[0]->index + 1;
2103
2104 /* put any pages we aren't going to use */
2105 for (i = nr_pages; i < found_pages; i++) {
2106 put_page(wdata->pages[i]);
2107 wdata->pages[i] = NULL;
2108 }
2109
2110 return nr_pages;
2111 }
2112
2113 static int
2114 wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2115 struct address_space *mapping, struct writeback_control *wbc)
2116 {
2117 int rc;
2118 struct TCP_Server_Info *server =
2119 tlink_tcon(wdata->cfile->tlink)->ses->server;
2120
2121 wdata->sync_mode = wbc->sync_mode;
2122 wdata->nr_pages = nr_pages;
2123 wdata->offset = page_offset(wdata->pages[0]);
2124 wdata->pagesz = PAGE_SIZE;
2125 wdata->tailsz = min(i_size_read(mapping->host) -
2126 page_offset(wdata->pages[nr_pages - 1]),
2127 (loff_t)PAGE_SIZE);
2128 wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2129 wdata->pid = wdata->cfile->pid;
2130
2131 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2132 if (rc)
2133 return rc;
2134
2135 if (wdata->cfile->invalidHandle)
2136 rc = -EAGAIN;
2137 else
2138 rc = server->ops->async_writev(wdata, cifs_writedata_release);
2139
2140 return rc;
2141 }
2142
2143 static int cifs_writepages(struct address_space *mapping,
2144 struct writeback_control *wbc)
2145 {
2146 struct inode *inode = mapping->host;
2147 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2148 struct TCP_Server_Info *server;
2149 bool done = false, scanned = false, range_whole = false;
2150 pgoff_t end, index;
2151 struct cifs_writedata *wdata;
2152 struct cifsFileInfo *cfile = NULL;
2153 int rc = 0;
2154 int saved_rc = 0;
2155 unsigned int xid;
2156
2157 /*
2158 * If wsize is smaller than the page cache size, default to writing
2159 * one page at a time via cifs_writepage
2160 */
2161 if (cifs_sb->wsize < PAGE_SIZE)
2162 return generic_writepages(mapping, wbc);
2163
2164 xid = get_xid();
2165 if (wbc->range_cyclic) {
2166 index = mapping->writeback_index; /* Start from prev offset */
2167 end = -1;
2168 } else {
2169 index = wbc->range_start >> PAGE_SHIFT;
2170 end = wbc->range_end >> PAGE_SHIFT;
2171 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2172 range_whole = true;
2173 scanned = true;
2174 }
2175 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
2176 retry:
2177 while (!done && index <= end) {
2178 unsigned int i, nr_pages, found_pages, wsize;
2179 pgoff_t next = 0, tofind, saved_index = index;
2180 struct cifs_credits credits_on_stack;
2181 struct cifs_credits *credits = &credits_on_stack;
2182 int get_file_rc = 0;
2183
2184 if (cfile)
2185 cifsFileInfo_put(cfile);
2186
2187 rc = cifs_get_writable_file(CIFS_I(inode), false, &cfile);
2188
2189 /* in case of an error store it to return later */
2190 if (rc)
2191 get_file_rc = rc;
2192
2193 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2194 &wsize, credits);
2195 if (rc != 0) {
2196 done = true;
2197 break;
2198 }
2199
2200 tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2201
2202 wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2203 &found_pages);
2204 if (!wdata) {
2205 rc = -ENOMEM;
2206 done = true;
2207 add_credits_and_wake_if(server, credits, 0);
2208 break;
2209 }
2210
2211 if (found_pages == 0) {
2212 kref_put(&wdata->refcount, cifs_writedata_release);
2213 add_credits_and_wake_if(server, credits, 0);
2214 break;
2215 }
2216
2217 nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2218 end, &index, &next, &done);
2219
2220 /* nothing to write? */
2221 if (nr_pages == 0) {
2222 kref_put(&wdata->refcount, cifs_writedata_release);
2223 add_credits_and_wake_if(server, credits, 0);
2224 continue;
2225 }
2226
2227 wdata->credits = credits_on_stack;
2228 wdata->cfile = cfile;
2229 cfile = NULL;
2230
2231 if (!wdata->cfile) {
2232 cifs_dbg(VFS, "No writable handle in writepages rc=%d\n",
2233 get_file_rc);
2234 if (is_retryable_error(get_file_rc))
2235 rc = get_file_rc;
2236 else
2237 rc = -EBADF;
2238 } else
2239 rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2240
2241 for (i = 0; i < nr_pages; ++i)
2242 unlock_page(wdata->pages[i]);
2243
2244 /* send failure -- clean up the mess */
2245 if (rc != 0) {
2246 add_credits_and_wake_if(server, &wdata->credits, 0);
2247 for (i = 0; i < nr_pages; ++i) {
2248 if (is_retryable_error(rc))
2249 redirty_page_for_writepage(wbc,
2250 wdata->pages[i]);
2251 else
2252 SetPageError(wdata->pages[i]);
2253 end_page_writeback(wdata->pages[i]);
2254 put_page(wdata->pages[i]);
2255 }
2256 if (!is_retryable_error(rc))
2257 mapping_set_error(mapping, rc);
2258 }
2259 kref_put(&wdata->refcount, cifs_writedata_release);
2260
2261 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2262 index = saved_index;
2263 continue;
2264 }
2265
2266 /* Return immediately if we received a signal during writing */
2267 if (is_interrupt_error(rc)) {
2268 done = true;
2269 break;
2270 }
2271
2272 if (rc != 0 && saved_rc == 0)
2273 saved_rc = rc;
2274
2275 wbc->nr_to_write -= nr_pages;
2276 if (wbc->nr_to_write <= 0)
2277 done = true;
2278
2279 index = next;
2280 }
2281
2282 if (!scanned && !done) {
2283 /*
2284 * We hit the last page and there is more work to be done: wrap
2285 * back to the start of the file
2286 */
2287 scanned = true;
2288 index = 0;
2289 goto retry;
2290 }
2291
2292 if (saved_rc != 0)
2293 rc = saved_rc;
2294
2295 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2296 mapping->writeback_index = index;
2297
2298 if (cfile)
2299 cifsFileInfo_put(cfile);
2300 free_xid(xid);
2301 return rc;
2302 }
2303
2304 static int
2305 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2306 {
2307 int rc;
2308 unsigned int xid;
2309
2310 xid = get_xid();
2311 /* BB add check for wbc flags */
2312 get_page(page);
2313 if (!PageUptodate(page))
2314 cifs_dbg(FYI, "ppw - page not up to date\n");
2315
2316 /*
2317 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2318 *
2319 * A writepage() implementation always needs to do either this,
2320 * or re-dirty the page with "redirty_page_for_writepage()" in
2321 * the case of a failure.
2322 *
2323 * Just unlocking the page will cause the radix tree tag-bits
2324 * to fail to update with the state of the page correctly.
2325 */
2326 set_page_writeback(page);
2327 retry_write:
2328 rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2329 if (is_retryable_error(rc)) {
2330 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN)
2331 goto retry_write;
2332 redirty_page_for_writepage(wbc, page);
2333 } else if (rc != 0) {
2334 SetPageError(page);
2335 mapping_set_error(page->mapping, rc);
2336 } else {
2337 SetPageUptodate(page);
2338 }
2339 end_page_writeback(page);
2340 put_page(page);
2341 free_xid(xid);
2342 return rc;
2343 }
2344
2345 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2346 {
2347 int rc = cifs_writepage_locked(page, wbc);
2348 unlock_page(page);
2349 return rc;
2350 }
2351
2352 static int cifs_write_end(struct file *file, struct address_space *mapping,
2353 loff_t pos, unsigned len, unsigned copied,
2354 struct page *page, void *fsdata)
2355 {
2356 int rc;
2357 struct inode *inode = mapping->host;
2358 struct cifsFileInfo *cfile = file->private_data;
2359 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2360 __u32 pid;
2361
2362 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2363 pid = cfile->pid;
2364 else
2365 pid = current->tgid;
2366
2367 cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2368 page, pos, copied);
2369
2370 if (PageChecked(page)) {
2371 if (copied == len)
2372 SetPageUptodate(page);
2373 ClearPageChecked(page);
2374 } else if (!PageUptodate(page) && copied == PAGE_SIZE)
2375 SetPageUptodate(page);
2376
2377 if (!PageUptodate(page)) {
2378 char *page_data;
2379 unsigned offset = pos & (PAGE_SIZE - 1);
2380 unsigned int xid;
2381
2382 xid = get_xid();
2383 /* this is probably better than directly calling
2384 partialpage_write since in this function the file handle is
2385 known which we might as well leverage */
2386 /* BB check if anything else missing out of ppw
2387 such as updating last write time */
2388 page_data = kmap(page);
2389 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2390 /* if (rc < 0) should we set writebehind rc? */
2391 kunmap(page);
2392
2393 free_xid(xid);
2394 } else {
2395 rc = copied;
2396 pos += copied;
2397 set_page_dirty(page);
2398 }
2399
2400 if (rc > 0) {
2401 spin_lock(&inode->i_lock);
2402 if (pos > inode->i_size)
2403 i_size_write(inode, pos);
2404 spin_unlock(&inode->i_lock);
2405 }
2406
2407 unlock_page(page);
2408 put_page(page);
2409
2410 return rc;
2411 }
2412
2413 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2414 int datasync)
2415 {
2416 unsigned int xid;
2417 int rc = 0;
2418 struct cifs_tcon *tcon;
2419 struct TCP_Server_Info *server;
2420 struct cifsFileInfo *smbfile = file->private_data;
2421 struct inode *inode = file_inode(file);
2422 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2423
2424 rc = file_write_and_wait_range(file, start, end);
2425 if (rc)
2426 return rc;
2427 inode_lock(inode);
2428
2429 xid = get_xid();
2430
2431 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2432 file, datasync);
2433
2434 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2435 rc = cifs_zap_mapping(inode);
2436 if (rc) {
2437 cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2438 rc = 0; /* don't care about it in fsync */
2439 }
2440 }
2441
2442 tcon = tlink_tcon(smbfile->tlink);
2443 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2444 server = tcon->ses->server;
2445 if (server->ops->flush)
2446 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2447 else
2448 rc = -ENOSYS;
2449 }
2450
2451 free_xid(xid);
2452 inode_unlock(inode);
2453 return rc;
2454 }
2455
2456 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2457 {
2458 unsigned int xid;
2459 int rc = 0;
2460 struct cifs_tcon *tcon;
2461 struct TCP_Server_Info *server;
2462 struct cifsFileInfo *smbfile = file->private_data;
2463 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2464 struct inode *inode = file->f_mapping->host;
2465
2466 rc = file_write_and_wait_range(file, start, end);
2467 if (rc)
2468 return rc;
2469 inode_lock(inode);
2470
2471 xid = get_xid();
2472
2473 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2474 file, datasync);
2475
2476 tcon = tlink_tcon(smbfile->tlink);
2477 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2478 server = tcon->ses->server;
2479 if (server->ops->flush)
2480 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2481 else
2482 rc = -ENOSYS;
2483 }
2484
2485 free_xid(xid);
2486 inode_unlock(inode);
2487 return rc;
2488 }
2489
2490 /*
2491 * As file closes, flush all cached write data for this inode checking
2492 * for write behind errors.
2493 */
2494 int cifs_flush(struct file *file, fl_owner_t id)
2495 {
2496 struct inode *inode = file_inode(file);
2497 int rc = 0;
2498
2499 if (file->f_mode & FMODE_WRITE)
2500 rc = filemap_write_and_wait(inode->i_mapping);
2501
2502 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2503
2504 return rc;
2505 }
2506
2507 static int
2508 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2509 {
2510 int rc = 0;
2511 unsigned long i;
2512
2513 for (i = 0; i < num_pages; i++) {
2514 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2515 if (!pages[i]) {
2516 /*
2517 * save number of pages we have already allocated and
2518 * return with ENOMEM error
2519 */
2520 num_pages = i;
2521 rc = -ENOMEM;
2522 break;
2523 }
2524 }
2525
2526 if (rc) {
2527 for (i = 0; i < num_pages; i++)
2528 put_page(pages[i]);
2529 }
2530 return rc;
2531 }
2532
2533 static inline
2534 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2535 {
2536 size_t num_pages;
2537 size_t clen;
2538
2539 clen = min_t(const size_t, len, wsize);
2540 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2541
2542 if (cur_len)
2543 *cur_len = clen;
2544
2545 return num_pages;
2546 }
2547
2548 static void
2549 cifs_uncached_writedata_release(struct kref *refcount)
2550 {
2551 int i;
2552 struct cifs_writedata *wdata = container_of(refcount,
2553 struct cifs_writedata, refcount);
2554
2555 kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
2556 for (i = 0; i < wdata->nr_pages; i++)
2557 put_page(wdata->pages[i]);
2558 cifs_writedata_release(refcount);
2559 }
2560
2561 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);
2562
2563 static void
2564 cifs_uncached_writev_complete(struct work_struct *work)
2565 {
2566 struct cifs_writedata *wdata = container_of(work,
2567 struct cifs_writedata, work);
2568 struct inode *inode = d_inode(wdata->cfile->dentry);
2569 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2570
2571 spin_lock(&inode->i_lock);
2572 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2573 if (cifsi->server_eof > inode->i_size)
2574 i_size_write(inode, cifsi->server_eof);
2575 spin_unlock(&inode->i_lock);
2576
2577 complete(&wdata->done);
2578 collect_uncached_write_data(wdata->ctx);
2579 /* the below call can possibly free the last ref to aio ctx */
2580 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2581 }
2582
2583 static int
2584 wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2585 size_t *len, unsigned long *num_pages)
2586 {
2587 size_t save_len, copied, bytes, cur_len = *len;
2588 unsigned long i, nr_pages = *num_pages;
2589
2590 save_len = cur_len;
2591 for (i = 0; i < nr_pages; i++) {
2592 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2593 copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2594 cur_len -= copied;
2595 /*
2596 * If we didn't copy as much as we expected, then that
2597 * may mean we trod into an unmapped area. Stop copying
2598 * at that point. On the next pass through the big
2599 * loop, we'll likely end up getting a zero-length
2600 * write and bailing out of it.
2601 */
2602 if (copied < bytes)
2603 break;
2604 }
2605 cur_len = save_len - cur_len;
2606 *len = cur_len;
2607
2608 /*
2609 * If we have no data to send, then that probably means that
2610 * the copy above failed altogether. That's most likely because
2611 * the address in the iovec was bogus. Return -EFAULT and let
2612 * the caller free anything we allocated and bail out.
2613 */
2614 if (!cur_len)
2615 return -EFAULT;
2616
2617 /*
2618 * i + 1 now represents the number of pages we actually used in
2619 * the copy phase above.
2620 */
2621 *num_pages = i + 1;
2622 return 0;
2623 }
2624
2625 static int
2626 cifs_resend_wdata(struct cifs_writedata *wdata, struct list_head *wdata_list,
2627 struct cifs_aio_ctx *ctx)
2628 {
2629 unsigned int wsize;
2630 struct cifs_credits credits;
2631 int rc;
2632 struct TCP_Server_Info *server =
2633 tlink_tcon(wdata->cfile->tlink)->ses->server;
2634
2635 /*
2636 * Wait for credits to resend this wdata.
2637 * Note: we are attempting to resend the whole wdata not in segments
2638 */
2639 do {
2640 rc = server->ops->wait_mtu_credits(server, wdata->bytes, &wsize,
2641 &credits);
2642
2643 if (rc)
2644 goto out;
2645
2646 if (wsize < wdata->bytes) {
2647 add_credits_and_wake_if(server, &credits, 0);
2648 msleep(1000);
2649 }
2650 } while (wsize < wdata->bytes);
2651
2652 wdata->credits = credits;
2653 rc = -EAGAIN;
2654 while (rc == -EAGAIN) {
2655 rc = 0;
2656 if (wdata->cfile->invalidHandle)
2657 rc = cifs_reopen_file(wdata->cfile, false);
2658 if (!rc)
2659 rc = server->ops->async_writev(wdata,
2660 cifs_uncached_writedata_release);
2661 }
2662
2663 if (!rc) {
2664 list_add_tail(&wdata->list, wdata_list);
2665 return 0;
2666 }
2667
2668 add_credits_and_wake_if(server, &wdata->credits, 0);
2669 out:
2670 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2671
2672 return rc;
2673 }
2674
2675 static int
2676 cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2677 struct cifsFileInfo *open_file,
2678 struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
2679 struct cifs_aio_ctx *ctx)
2680 {
2681 int rc = 0;
2682 size_t cur_len;
2683 unsigned long nr_pages, num_pages, i;
2684 struct cifs_writedata *wdata;
2685 struct iov_iter saved_from = *from;
2686 loff_t saved_offset = offset;
2687 pid_t pid;
2688 struct TCP_Server_Info *server;
2689 struct page **pagevec;
2690 size_t start;
2691 unsigned int xid;
2692
2693 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2694 pid = open_file->pid;
2695 else
2696 pid = current->tgid;
2697
2698 server = tlink_tcon(open_file->tlink)->ses->server;
2699 xid = get_xid();
2700
2701 do {
2702 unsigned int wsize;
2703 struct cifs_credits credits_on_stack;
2704 struct cifs_credits *credits = &credits_on_stack;
2705
2706 if (open_file->invalidHandle) {
2707 rc = cifs_reopen_file(open_file, false);
2708 if (rc == -EAGAIN)
2709 continue;
2710 else if (rc)
2711 break;
2712 }
2713
2714 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2715 &wsize, credits);
2716 if (rc)
2717 break;
2718
2719 cur_len = min_t(const size_t, len, wsize);
2720
2721 if (ctx->direct_io) {
2722 ssize_t result;
2723
2724 result = iov_iter_get_pages_alloc(
2725 from, &pagevec, cur_len, &start);
2726 if (result < 0) {
2727 cifs_dbg(VFS,
2728 "direct_writev couldn't get user pages "
2729 "(rc=%zd) iter type %d iov_offset %zd "
2730 "count %zd\n",
2731 result, from->type,
2732 from->iov_offset, from->count);
2733 dump_stack();
2734
2735 rc = result;
2736 add_credits_and_wake_if(server, credits, 0);
2737 break;
2738 }
2739 cur_len = (size_t)result;
2740 iov_iter_advance(from, cur_len);
2741
2742 nr_pages =
2743 (cur_len + start + PAGE_SIZE - 1) / PAGE_SIZE;
2744
2745 wdata = cifs_writedata_direct_alloc(pagevec,
2746 cifs_uncached_writev_complete);
2747 if (!wdata) {
2748 rc = -ENOMEM;
2749 add_credits_and_wake_if(server, credits, 0);
2750 break;
2751 }
2752
2753
2754 wdata->page_offset = start;
2755 wdata->tailsz =
2756 nr_pages > 1 ?
2757 cur_len - (PAGE_SIZE - start) -
2758 (nr_pages - 2) * PAGE_SIZE :
2759 cur_len;
2760 } else {
2761 nr_pages = get_numpages(wsize, len, &cur_len);
2762 wdata = cifs_writedata_alloc(nr_pages,
2763 cifs_uncached_writev_complete);
2764 if (!wdata) {
2765 rc = -ENOMEM;
2766 add_credits_and_wake_if(server, credits, 0);
2767 break;
2768 }
2769
2770 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2771 if (rc) {
2772 kvfree(wdata->pages);
2773 kfree(wdata);
2774 add_credits_and_wake_if(server, credits, 0);
2775 break;
2776 }
2777
2778 num_pages = nr_pages;
2779 rc = wdata_fill_from_iovec(
2780 wdata, from, &cur_len, &num_pages);
2781 if (rc) {
2782 for (i = 0; i < nr_pages; i++)
2783 put_page(wdata->pages[i]);
2784 kvfree(wdata->pages);
2785 kfree(wdata);
2786 add_credits_and_wake_if(server, credits, 0);
2787 break;
2788 }
2789
2790 /*
2791 * Bring nr_pages down to the number of pages we
2792 * actually used, and free any pages that we didn't use.
2793 */
2794 for ( ; nr_pages > num_pages; nr_pages--)
2795 put_page(wdata->pages[nr_pages - 1]);
2796
2797 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2798 }
2799
2800 wdata->sync_mode = WB_SYNC_ALL;
2801 wdata->nr_pages = nr_pages;
2802 wdata->offset = (__u64)offset;
2803 wdata->cfile = cifsFileInfo_get(open_file);
2804 wdata->pid = pid;
2805 wdata->bytes = cur_len;
2806 wdata->pagesz = PAGE_SIZE;
2807 wdata->credits = credits_on_stack;
2808 wdata->ctx = ctx;
2809 kref_get(&ctx->refcount);
2810
2811 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2812
2813 if (!rc) {
2814 if (wdata->cfile->invalidHandle)
2815 rc = -EAGAIN;
2816 else
2817 rc = server->ops->async_writev(wdata,
2818 cifs_uncached_writedata_release);
2819 }
2820
2821 if (rc) {
2822 add_credits_and_wake_if(server, &wdata->credits, 0);
2823 kref_put(&wdata->refcount,
2824 cifs_uncached_writedata_release);
2825 if (rc == -EAGAIN) {
2826 *from = saved_from;
2827 iov_iter_advance(from, offset - saved_offset);
2828 continue;
2829 }
2830 break;
2831 }
2832
2833 list_add_tail(&wdata->list, wdata_list);
2834 offset += cur_len;
2835 len -= cur_len;
2836 } while (len > 0);
2837
2838 free_xid(xid);
2839 return rc;
2840 }
2841
2842 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
2843 {
2844 struct cifs_writedata *wdata, *tmp;
2845 struct cifs_tcon *tcon;
2846 struct cifs_sb_info *cifs_sb;
2847 struct dentry *dentry = ctx->cfile->dentry;
2848 unsigned int i;
2849 int rc;
2850
2851 tcon = tlink_tcon(ctx->cfile->tlink);
2852 cifs_sb = CIFS_SB(dentry->d_sb);
2853
2854 mutex_lock(&ctx->aio_mutex);
2855
2856 if (list_empty(&ctx->list)) {
2857 mutex_unlock(&ctx->aio_mutex);
2858 return;
2859 }
2860
2861 rc = ctx->rc;
2862 /*
2863 * Wait for and collect replies for any successful sends in order of
2864 * increasing offset. Once an error is hit, then return without waiting
2865 * for any more replies.
2866 */
2867 restart_loop:
2868 list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
2869 if (!rc) {
2870 if (!try_wait_for_completion(&wdata->done)) {
2871 mutex_unlock(&ctx->aio_mutex);
2872 return;
2873 }
2874
2875 if (wdata->result)
2876 rc = wdata->result;
2877 else
2878 ctx->total_len += wdata->bytes;
2879
2880 /* resend call if it's a retryable error */
2881 if (rc == -EAGAIN) {
2882 struct list_head tmp_list;
2883 struct iov_iter tmp_from = ctx->iter;
2884
2885 INIT_LIST_HEAD(&tmp_list);
2886 list_del_init(&wdata->list);
2887
2888 if (ctx->direct_io)
2889 rc = cifs_resend_wdata(
2890 wdata, &tmp_list, ctx);
2891 else {
2892 iov_iter_advance(&tmp_from,
2893 wdata->offset - ctx->pos);
2894
2895 rc = cifs_write_from_iter(wdata->offset,
2896 wdata->bytes, &tmp_from,
2897 ctx->cfile, cifs_sb, &tmp_list,
2898 ctx);
2899 }
2900
2901 list_splice(&tmp_list, &ctx->list);
2902
2903 kref_put(&wdata->refcount,
2904 cifs_uncached_writedata_release);
2905 goto restart_loop;
2906 }
2907 }
2908 list_del_init(&wdata->list);
2909 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2910 }
2911
2912 if (!ctx->direct_io)
2913 for (i = 0; i < ctx->npages; i++)
2914 put_page(ctx->bv[i].bv_page);
2915
2916 cifs_stats_bytes_written(tcon, ctx->total_len);
2917 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);
2918
2919 ctx->rc = (rc == 0) ? ctx->total_len : rc;
2920
2921 mutex_unlock(&ctx->aio_mutex);
2922
2923 if (ctx->iocb && ctx->iocb->ki_complete)
2924 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
2925 else
2926 complete(&ctx->done);
2927 }
2928
2929 static ssize_t __cifs_writev(
2930 struct kiocb *iocb, struct iov_iter *from, bool direct)
2931 {
2932 struct file *file = iocb->ki_filp;
2933 ssize_t total_written = 0;
2934 struct cifsFileInfo *cfile;
2935 struct cifs_tcon *tcon;
2936 struct cifs_sb_info *cifs_sb;
2937 struct cifs_aio_ctx *ctx;
2938 struct iov_iter saved_from = *from;
2939 size_t len = iov_iter_count(from);
2940 int rc;
2941
2942 /*
2943 * iov_iter_get_pages_alloc doesn't work with ITER_KVEC.
2944 * In this case, fall back to non-direct write function.
2945 * this could be improved by getting pages directly in ITER_KVEC
2946 */
2947 if (direct && from->type & ITER_KVEC) {
2948 cifs_dbg(FYI, "use non-direct cifs_writev for kvec I/O\n");
2949 direct = false;
2950 }
2951
2952 rc = generic_write_checks(iocb, from);
2953 if (rc <= 0)
2954 return rc;
2955
2956 cifs_sb = CIFS_FILE_SB(file);
2957 cfile = file->private_data;
2958 tcon = tlink_tcon(cfile->tlink);
2959
2960 if (!tcon->ses->server->ops->async_writev)
2961 return -ENOSYS;
2962
2963 ctx = cifs_aio_ctx_alloc();
2964 if (!ctx)
2965 return -ENOMEM;
2966
2967 ctx->cfile = cifsFileInfo_get(cfile);
2968
2969 if (!is_sync_kiocb(iocb))
2970 ctx->iocb = iocb;
2971
2972 ctx->pos = iocb->ki_pos;
2973
2974 if (direct) {
2975 ctx->direct_io = true;
2976 ctx->iter = *from;
2977 ctx->len = len;
2978 } else {
2979 rc = setup_aio_ctx_iter(ctx, from, WRITE);
2980 if (rc) {
2981 kref_put(&ctx->refcount, cifs_aio_ctx_release);
2982 return rc;
2983 }
2984 }
2985
2986 /* grab a lock here due to read response handlers can access ctx */
2987 mutex_lock(&ctx->aio_mutex);
2988
2989 rc = cifs_write_from_iter(iocb->ki_pos, ctx->len, &saved_from,
2990 cfile, cifs_sb, &ctx->list, ctx);
2991
2992 /*
2993 * If at least one write was successfully sent, then discard any rc
2994 * value from the later writes. If the other write succeeds, then
2995 * we'll end up returning whatever was written. If it fails, then
2996 * we'll get a new rc value from that.
2997 */
2998 if (!list_empty(&ctx->list))
2999 rc = 0;
3000
3001 mutex_unlock(&ctx->aio_mutex);
3002
3003 if (rc) {
3004 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3005 return rc;
3006 }
3007
3008 if (!is_sync_kiocb(iocb)) {
3009 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3010 return -EIOCBQUEUED;
3011 }
3012
3013 rc = wait_for_completion_killable(&ctx->done);
3014 if (rc) {
3015 mutex_lock(&ctx->aio_mutex);
3016 ctx->rc = rc = -EINTR;
3017 total_written = ctx->total_len;
3018 mutex_unlock(&ctx->aio_mutex);
3019 } else {
3020 rc = ctx->rc;
3021 total_written = ctx->total_len;
3022 }
3023
3024 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3025
3026 if (unlikely(!total_written))
3027 return rc;
3028
3029 iocb->ki_pos += total_written;
3030 return total_written;
3031 }
3032
3033 ssize_t cifs_direct_writev(struct kiocb *iocb, struct iov_iter *from)
3034 {
3035 return __cifs_writev(iocb, from, true);
3036 }
3037
3038 ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
3039 {
3040 return __cifs_writev(iocb, from, false);
3041 }
3042
3043 static ssize_t
3044 cifs_writev(struct kiocb *iocb, struct iov_iter *from)
3045 {
3046 struct file *file = iocb->ki_filp;
3047 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
3048 struct inode *inode = file->f_mapping->host;
3049 struct cifsInodeInfo *cinode = CIFS_I(inode);
3050 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
3051 ssize_t rc;
3052
3053 inode_lock(inode);
3054 /*
3055 * We need to hold the sem to be sure nobody modifies lock list
3056 * with a brlock that prevents writing.
3057 */
3058 down_read(&cinode->lock_sem);
3059
3060 rc = generic_write_checks(iocb, from);
3061 if (rc <= 0)
3062 goto out;
3063
3064 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
3065 server->vals->exclusive_lock_type, 0,
3066 NULL, CIFS_WRITE_OP))
3067 rc = __generic_file_write_iter(iocb, from);
3068 else
3069 rc = -EACCES;
3070 out:
3071 up_read(&cinode->lock_sem);
3072 inode_unlock(inode);
3073
3074 if (rc > 0)
3075 rc = generic_write_sync(iocb, rc);
3076 return rc;
3077 }
3078
3079 ssize_t
3080 cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
3081 {
3082 struct inode *inode = file_inode(iocb->ki_filp);
3083 struct cifsInodeInfo *cinode = CIFS_I(inode);
3084 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3085 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3086 iocb->ki_filp->private_data;
3087 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3088 ssize_t written;
3089
3090 written = cifs_get_writer(cinode);
3091 if (written)
3092 return written;
3093
3094 if (CIFS_CACHE_WRITE(cinode)) {
3095 if (cap_unix(tcon->ses) &&
3096 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
3097 && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
3098 written = generic_file_write_iter(iocb, from);
3099 goto out;
3100 }
3101 written = cifs_writev(iocb, from);
3102 goto out;
3103 }
3104 /*
3105 * For non-oplocked files in strict cache mode we need to write the data
3106 * to the server exactly from the pos to pos+len-1 rather than flush all
3107 * affected pages because it may cause a error with mandatory locks on
3108 * these pages but not on the region from pos to ppos+len-1.
3109 */
3110 written = cifs_user_writev(iocb, from);
3111 if (CIFS_CACHE_READ(cinode)) {
3112 /*
3113 * We have read level caching and we have just sent a write
3114 * request to the server thus making data in the cache stale.
3115 * Zap the cache and set oplock/lease level to NONE to avoid
3116 * reading stale data from the cache. All subsequent read
3117 * operations will read new data from the server.
3118 */
3119 cifs_zap_mapping(inode);
3120 cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
3121 inode);
3122 cinode->oplock = 0;
3123 }
3124 out:
3125 cifs_put_writer(cinode);
3126 return written;
3127 }
3128
3129 static struct cifs_readdata *
3130 cifs_readdata_direct_alloc(struct page **pages, work_func_t complete)
3131 {
3132 struct cifs_readdata *rdata;
3133
3134 rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
3135 if (rdata != NULL) {
3136 rdata->pages = pages;
3137 kref_init(&rdata->refcount);
3138 INIT_LIST_HEAD(&rdata->list);
3139 init_completion(&rdata->done);
3140 INIT_WORK(&rdata->work, complete);
3141 }
3142
3143 return rdata;
3144 }
3145
3146 static struct cifs_readdata *
3147 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
3148 {
3149 struct page **pages =
3150 kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
3151 struct cifs_readdata *ret = NULL;
3152
3153 if (pages) {
3154 ret = cifs_readdata_direct_alloc(pages, complete);
3155 if (!ret)
3156 kfree(pages);
3157 }
3158
3159 return ret;
3160 }
3161
3162 void
3163 cifs_readdata_release(struct kref *refcount)
3164 {
3165 struct cifs_readdata *rdata = container_of(refcount,
3166 struct cifs_readdata, refcount);
3167 #ifdef CONFIG_CIFS_SMB_DIRECT
3168 if (rdata->mr) {
3169 smbd_deregister_mr(rdata->mr);
3170 rdata->mr = NULL;
3171 }
3172 #endif
3173 if (rdata->cfile)
3174 cifsFileInfo_put(rdata->cfile);
3175
3176 kvfree(rdata->pages);
3177 kfree(rdata);
3178 }
3179
3180 static int
3181 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
3182 {
3183 int rc = 0;
3184 struct page *page;
3185 unsigned int i;
3186
3187 for (i = 0; i < nr_pages; i++) {
3188 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
3189 if (!page) {
3190 rc = -ENOMEM;
3191 break;
3192 }
3193 rdata->pages[i] = page;
3194 }
3195
3196 if (rc) {
3197 for (i = 0; i < nr_pages; i++) {
3198 put_page(rdata->pages[i]);
3199 rdata->pages[i] = NULL;
3200 }
3201 }
3202 return rc;
3203 }
3204
3205 static void
3206 cifs_uncached_readdata_release(struct kref *refcount)
3207 {
3208 struct cifs_readdata *rdata = container_of(refcount,
3209 struct cifs_readdata, refcount);
3210 unsigned int i;
3211
3212 kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
3213 for (i = 0; i < rdata->nr_pages; i++) {
3214 put_page(rdata->pages[i]);
3215 }
3216 cifs_readdata_release(refcount);
3217 }
3218
3219 /**
3220 * cifs_readdata_to_iov - copy data from pages in response to an iovec
3221 * @rdata: the readdata response with list of pages holding data
3222 * @iter: destination for our data
3223 *
3224 * This function copies data from a list of pages in a readdata response into
3225 * an array of iovecs. It will first calculate where the data should go
3226 * based on the info in the readdata and then copy the data into that spot.
3227 */
3228 static int
3229 cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3230 {
3231 size_t remaining = rdata->got_bytes;
3232 unsigned int i;
3233
3234 for (i = 0; i < rdata->nr_pages; i++) {
3235 struct page *page = rdata->pages[i];
3236 size_t copy = min_t(size_t, remaining, PAGE_SIZE);
3237 size_t written;
3238
3239 if (unlikely(iov_iter_is_pipe(iter))) {
3240 void *addr = kmap_atomic(page);
3241
3242 written = copy_to_iter(addr, copy, iter);
3243 kunmap_atomic(addr);
3244 } else
3245 written = copy_page_to_iter(page, 0, copy, iter);
3246 remaining -= written;
3247 if (written < copy && iov_iter_count(iter) > 0)
3248 break;
3249 }
3250 return remaining ? -EFAULT : 0;
3251 }
3252
3253 static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);
3254
3255 static void
3256 cifs_uncached_readv_complete(struct work_struct *work)
3257 {
3258 struct cifs_readdata *rdata = container_of(work,
3259 struct cifs_readdata, work);
3260
3261 complete(&rdata->done);
3262 collect_uncached_read_data(rdata->ctx);
3263 /* the below call can possibly free the last ref to aio ctx */
3264 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3265 }
3266
3267 static int
3268 uncached_fill_pages(struct TCP_Server_Info *server,
3269 struct cifs_readdata *rdata, struct iov_iter *iter,
3270 unsigned int len)
3271 {
3272 int result = 0;
3273 unsigned int i;
3274 unsigned int nr_pages = rdata->nr_pages;
3275 unsigned int page_offset = rdata->page_offset;
3276
3277 rdata->got_bytes = 0;
3278 rdata->tailsz = PAGE_SIZE;
3279 for (i = 0; i < nr_pages; i++) {
3280 struct page *page = rdata->pages[i];
3281 size_t n;
3282 unsigned int segment_size = rdata->pagesz;
3283
3284 if (i == 0)
3285 segment_size -= page_offset;
3286 else
3287 page_offset = 0;
3288
3289
3290 if (len <= 0) {
3291 /* no need to hold page hostage */
3292 rdata->pages[i] = NULL;
3293 rdata->nr_pages--;
3294 put_page(page);
3295 continue;
3296 }
3297
3298 n = len;
3299 if (len >= segment_size)
3300 /* enough data to fill the page */
3301 n = segment_size;
3302 else
3303 rdata->tailsz = len;
3304 len -= n;
3305
3306 if (iter)
3307 result = copy_page_from_iter(
3308 page, page_offset, n, iter);
3309 #ifdef CONFIG_CIFS_SMB_DIRECT
3310 else if (rdata->mr)
3311 result = n;
3312 #endif
3313 else
3314 result = cifs_read_page_from_socket(
3315 server, page, page_offset, n);
3316 if (result < 0)
3317 break;
3318
3319 rdata->got_bytes += result;
3320 }
3321
3322 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3323 rdata->got_bytes : result;
3324 }
3325
3326 static int
3327 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
3328 struct cifs_readdata *rdata, unsigned int len)
3329 {
3330 return uncached_fill_pages(server, rdata, NULL, len);
3331 }
3332
3333 static int
3334 cifs_uncached_copy_into_pages(struct TCP_Server_Info *server,
3335 struct cifs_readdata *rdata,
3336 struct iov_iter *iter)
3337 {
3338 return uncached_fill_pages(server, rdata, iter, iter->count);
3339 }
3340
3341 static int cifs_resend_rdata(struct cifs_readdata *rdata,
3342 struct list_head *rdata_list,
3343 struct cifs_aio_ctx *ctx)
3344 {
3345 unsigned int rsize;
3346 struct cifs_credits credits;
3347 int rc;
3348 struct TCP_Server_Info *server =
3349 tlink_tcon(rdata->cfile->tlink)->ses->server;
3350
3351 /*
3352 * Wait for credits to resend this rdata.
3353 * Note: we are attempting to resend the whole rdata not in segments
3354 */
3355 do {
3356 rc = server->ops->wait_mtu_credits(server, rdata->bytes,
3357 &rsize, &credits);
3358
3359 if (rc)
3360 goto out;
3361
3362 if (rsize < rdata->bytes) {
3363 add_credits_and_wake_if(server, &credits, 0);
3364 msleep(1000);
3365 }
3366 } while (rsize < rdata->bytes);
3367
3368 rdata->credits = credits;
3369 rc = -EAGAIN;
3370 while (rc == -EAGAIN) {
3371 rc = 0;
3372 if (rdata->cfile->invalidHandle)
3373 rc = cifs_reopen_file(rdata->cfile, true);
3374 if (!rc)
3375 rc = server->ops->async_readv(rdata);
3376 }
3377
3378 if (!rc) {
3379 /* Add to aio pending list */
3380 list_add_tail(&rdata->list, rdata_list);
3381 return 0;
3382 }
3383
3384 add_credits_and_wake_if(server, &rdata->credits, 0);
3385 out:
3386 kref_put(&rdata->refcount,
3387 cifs_uncached_readdata_release);
3388
3389 return rc;
3390 }
3391
3392 static int
3393 cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3394 struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
3395 struct cifs_aio_ctx *ctx)
3396 {
3397 struct cifs_readdata *rdata;
3398 unsigned int npages, rsize;
3399 struct cifs_credits credits_on_stack;
3400 struct cifs_credits *credits = &credits_on_stack;
3401 size_t cur_len;
3402 int rc;
3403 pid_t pid;
3404 struct TCP_Server_Info *server;
3405 struct page **pagevec;
3406 size_t start;
3407 struct iov_iter direct_iov = ctx->iter;
3408
3409 server = tlink_tcon(open_file->tlink)->ses->server;
3410
3411 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3412 pid = open_file->pid;
3413 else
3414 pid = current->tgid;
3415
3416 if (ctx->direct_io)
3417 iov_iter_advance(&direct_iov, offset - ctx->pos);
3418
3419 do {
3420 if (open_file->invalidHandle) {
3421 rc = cifs_reopen_file(open_file, true);
3422 if (rc == -EAGAIN)
3423 continue;
3424 else if (rc)
3425 break;
3426 }
3427
3428 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3429 &rsize, credits);
3430 if (rc)
3431 break;
3432
3433 cur_len = min_t(const size_t, len, rsize);
3434
3435 if (ctx->direct_io) {
3436 ssize_t result;
3437
3438 result = iov_iter_get_pages_alloc(
3439 &direct_iov, &pagevec,
3440 cur_len, &start);
3441 if (result < 0) {
3442 cifs_dbg(VFS,
3443 "couldn't get user pages (rc=%zd)"
3444 " iter type %d"
3445 " iov_offset %zd count %zd\n",
3446 result, direct_iov.type,
3447 direct_iov.iov_offset,
3448 direct_iov.count);
3449 dump_stack();
3450
3451 rc = result;
3452 add_credits_and_wake_if(server, credits, 0);
3453 break;
3454 }
3455 cur_len = (size_t)result;
3456 iov_iter_advance(&direct_iov, cur_len);
3457
3458 rdata = cifs_readdata_direct_alloc(
3459 pagevec, cifs_uncached_readv_complete);
3460 if (!rdata) {
3461 add_credits_and_wake_if(server, credits, 0);
3462 rc = -ENOMEM;
3463 break;
3464 }
3465
3466 npages = (cur_len + start + PAGE_SIZE-1) / PAGE_SIZE;
3467 rdata->page_offset = start;
3468 rdata->tailsz = npages > 1 ?
3469 cur_len-(PAGE_SIZE-start)-(npages-2)*PAGE_SIZE :
3470 cur_len;
3471
3472 } else {
3473
3474 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
3475 /* allocate a readdata struct */
3476 rdata = cifs_readdata_alloc(npages,
3477 cifs_uncached_readv_complete);
3478 if (!rdata) {
3479 add_credits_and_wake_if(server, credits, 0);
3480 rc = -ENOMEM;
3481 break;
3482 }
3483
3484 rc = cifs_read_allocate_pages(rdata, npages);
3485 if (rc) {
3486 kvfree(rdata->pages);
3487 kfree(rdata);
3488 add_credits_and_wake_if(server, credits, 0);
3489 break;
3490 }
3491
3492 rdata->tailsz = PAGE_SIZE;
3493 }
3494
3495 rdata->cfile = cifsFileInfo_get(open_file);
3496 rdata->nr_pages = npages;
3497 rdata->offset = offset;
3498 rdata->bytes = cur_len;
3499 rdata->pid = pid;
3500 rdata->pagesz = PAGE_SIZE;
3501 rdata->read_into_pages = cifs_uncached_read_into_pages;
3502 rdata->copy_into_pages = cifs_uncached_copy_into_pages;
3503 rdata->credits = credits_on_stack;
3504 rdata->ctx = ctx;
3505 kref_get(&ctx->refcount);
3506
3507 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3508
3509 if (!rc) {
3510 if (rdata->cfile->invalidHandle)
3511 rc = -EAGAIN;
3512 else
3513 rc = server->ops->async_readv(rdata);
3514 }
3515
3516 if (rc) {
3517 add_credits_and_wake_if(server, &rdata->credits, 0);
3518 kref_put(&rdata->refcount,
3519 cifs_uncached_readdata_release);
3520 if (rc == -EAGAIN) {
3521 iov_iter_revert(&direct_iov, cur_len);
3522 continue;
3523 }
3524 break;
3525 }
3526
3527 list_add_tail(&rdata->list, rdata_list);
3528 offset += cur_len;
3529 len -= cur_len;
3530 } while (len > 0);
3531
3532 return rc;
3533 }
3534
3535 static void
3536 collect_uncached_read_data(struct cifs_aio_ctx *ctx)
3537 {
3538 struct cifs_readdata *rdata, *tmp;
3539 struct iov_iter *to = &ctx->iter;
3540 struct cifs_sb_info *cifs_sb;
3541 struct cifs_tcon *tcon;
3542 unsigned int i;
3543 int rc;
3544
3545 tcon = tlink_tcon(ctx->cfile->tlink);
3546 cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
3547
3548 mutex_lock(&ctx->aio_mutex);
3549
3550 if (list_empty(&ctx->list)) {
3551 mutex_unlock(&ctx->aio_mutex);
3552 return;
3553 }
3554
3555 rc = ctx->rc;
3556 /* the loop below should proceed in the order of increasing offsets */
3557 again:
3558 list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
3559 if (!rc) {
3560 if (!try_wait_for_completion(&rdata->done)) {
3561 mutex_unlock(&ctx->aio_mutex);
3562 return;
3563 }
3564
3565 if (rdata->result == -EAGAIN) {
3566 /* resend call if it's a retryable error */
3567 struct list_head tmp_list;
3568 unsigned int got_bytes = rdata->got_bytes;
3569
3570 list_del_init(&rdata->list);
3571 INIT_LIST_HEAD(&tmp_list);
3572
3573 /*
3574 * Got a part of data and then reconnect has
3575 * happened -- fill the buffer and continue
3576 * reading.
3577 */
3578 if (got_bytes && got_bytes < rdata->bytes) {
3579 rc = 0;
3580 if (!ctx->direct_io)
3581 rc = cifs_readdata_to_iov(rdata, to);
3582 if (rc) {
3583 kref_put(&rdata->refcount,
3584 cifs_uncached_readdata_release);
3585 continue;
3586 }
3587 }
3588
3589 if (ctx->direct_io) {
3590 /*
3591 * Re-use rdata as this is a
3592 * direct I/O
3593 */
3594 rc = cifs_resend_rdata(
3595 rdata,
3596 &tmp_list, ctx);
3597 } else {
3598 rc = cifs_send_async_read(
3599 rdata->offset + got_bytes,
3600 rdata->bytes - got_bytes,
3601 rdata->cfile, cifs_sb,
3602 &tmp_list, ctx);
3603
3604 kref_put(&rdata->refcount,
3605 cifs_uncached_readdata_release);
3606 }
3607
3608 list_splice(&tmp_list, &ctx->list);
3609
3610 goto again;
3611 } else if (rdata->result)
3612 rc = rdata->result;
3613 else if (!ctx->direct_io)
3614 rc = cifs_readdata_to_iov(rdata, to);
3615
3616 /* if there was a short read -- discard anything left */
3617 if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3618 rc = -ENODATA;
3619
3620 ctx->total_len += rdata->got_bytes;
3621 }
3622 list_del_init(&rdata->list);
3623 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3624 }
3625
3626 if (!ctx->direct_io) {
3627 for (i = 0; i < ctx->npages; i++) {
3628 if (ctx->should_dirty)
3629 set_page_dirty(ctx->bv[i].bv_page);
3630 put_page(ctx->bv[i].bv_page);
3631 }
3632
3633 ctx->total_len = ctx->len - iov_iter_count(to);
3634 }
3635
3636 /* mask nodata case */
3637 if (rc == -ENODATA)
3638 rc = 0;
3639
3640 ctx->rc = (rc == 0) ? ctx->total_len : rc;
3641
3642 mutex_unlock(&ctx->aio_mutex);
3643
3644 if (ctx->iocb && ctx->iocb->ki_complete)
3645 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
3646 else
3647 complete(&ctx->done);
3648 }
3649
3650 static ssize_t __cifs_readv(
3651 struct kiocb *iocb, struct iov_iter *to, bool direct)
3652 {
3653 size_t len;
3654 struct file *file = iocb->ki_filp;
3655 struct cifs_sb_info *cifs_sb;
3656 struct cifsFileInfo *cfile;
3657 struct cifs_tcon *tcon;
3658 ssize_t rc, total_read = 0;
3659 loff_t offset = iocb->ki_pos;
3660 struct cifs_aio_ctx *ctx;
3661
3662 /*
3663 * iov_iter_get_pages_alloc() doesn't work with ITER_KVEC,
3664 * fall back to data copy read path
3665 * this could be improved by getting pages directly in ITER_KVEC
3666 */
3667 if (direct && to->type & ITER_KVEC) {
3668 cifs_dbg(FYI, "use non-direct cifs_user_readv for kvec I/O\n");
3669 direct = false;
3670 }
3671
3672 len = iov_iter_count(to);
3673 if (!len)
3674 return 0;
3675
3676 cifs_sb = CIFS_FILE_SB(file);
3677 cfile = file->private_data;
3678 tcon = tlink_tcon(cfile->tlink);
3679
3680 if (!tcon->ses->server->ops->async_readv)
3681 return -ENOSYS;
3682
3683 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3684 cifs_dbg(FYI, "attempting read on write only file instance\n");
3685
3686 ctx = cifs_aio_ctx_alloc();
3687 if (!ctx)
3688 return -ENOMEM;
3689
3690 ctx->cfile = cifsFileInfo_get(cfile);
3691
3692 if (!is_sync_kiocb(iocb))
3693 ctx->iocb = iocb;
3694
3695 if (iter_is_iovec(to))
3696 ctx->should_dirty = true;
3697
3698 if (direct) {
3699 ctx->pos = offset;
3700 ctx->direct_io = true;
3701 ctx->iter = *to;
3702 ctx->len = len;
3703 } else {
3704 rc = setup_aio_ctx_iter(ctx, to, READ);
3705 if (rc) {
3706 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3707 return rc;
3708 }
3709 len = ctx->len;
3710 }
3711
3712 /* grab a lock here due to read response handlers can access ctx */
3713 mutex_lock(&ctx->aio_mutex);
3714
3715 rc = cifs_send_async_read(offset, len, cfile, cifs_sb, &ctx->list, ctx);
3716
3717 /* if at least one read request send succeeded, then reset rc */
3718 if (!list_empty(&ctx->list))
3719 rc = 0;
3720
3721 mutex_unlock(&ctx->aio_mutex);
3722
3723 if (rc) {
3724 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3725 return rc;
3726 }
3727
3728 if (!is_sync_kiocb(iocb)) {
3729 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3730 return -EIOCBQUEUED;
3731 }
3732
3733 rc = wait_for_completion_killable(&ctx->done);
3734 if (rc) {
3735 mutex_lock(&ctx->aio_mutex);
3736 ctx->rc = rc = -EINTR;
3737 total_read = ctx->total_len;
3738 mutex_unlock(&ctx->aio_mutex);
3739 } else {
3740 rc = ctx->rc;
3741 total_read = ctx->total_len;
3742 }
3743
3744 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3745
3746 if (total_read) {
3747 iocb->ki_pos += total_read;
3748 return total_read;
3749 }
3750 return rc;
3751 }
3752
3753 ssize_t cifs_direct_readv(struct kiocb *iocb, struct iov_iter *to)
3754 {
3755 return __cifs_readv(iocb, to, true);
3756 }
3757
3758 ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
3759 {
3760 return __cifs_readv(iocb, to, false);
3761 }
3762
3763 ssize_t
3764 cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3765 {
3766 struct inode *inode = file_inode(iocb->ki_filp);
3767 struct cifsInodeInfo *cinode = CIFS_I(inode);
3768 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3769 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3770 iocb->ki_filp->private_data;
3771 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3772 int rc = -EACCES;
3773
3774 /*
3775 * In strict cache mode we need to read from the server all the time
3776 * if we don't have level II oplock because the server can delay mtime
3777 * change - so we can't make a decision about inode invalidating.
3778 * And we can also fail with pagereading if there are mandatory locks
3779 * on pages affected by this read but not on the region from pos to
3780 * pos+len-1.
3781 */
3782 if (!CIFS_CACHE_READ(cinode))
3783 return cifs_user_readv(iocb, to);
3784
3785 if (cap_unix(tcon->ses) &&
3786 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3787 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
3788 return generic_file_read_iter(iocb, to);
3789
3790 /*
3791 * We need to hold the sem to be sure nobody modifies lock list
3792 * with a brlock that prevents reading.
3793 */
3794 down_read(&cinode->lock_sem);
3795 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3796 tcon->ses->server->vals->shared_lock_type,
3797 0, NULL, CIFS_READ_OP))
3798 rc = generic_file_read_iter(iocb, to);
3799 up_read(&cinode->lock_sem);
3800 return rc;
3801 }
3802
3803 static ssize_t
3804 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
3805 {
3806 int rc = -EACCES;
3807 unsigned int bytes_read = 0;
3808 unsigned int total_read;
3809 unsigned int current_read_size;
3810 unsigned int rsize;
3811 struct cifs_sb_info *cifs_sb;
3812 struct cifs_tcon *tcon;
3813 struct TCP_Server_Info *server;
3814 unsigned int xid;
3815 char *cur_offset;
3816 struct cifsFileInfo *open_file;
3817 struct cifs_io_parms io_parms;
3818 int buf_type = CIFS_NO_BUFFER;
3819 __u32 pid;
3820
3821 xid = get_xid();
3822 cifs_sb = CIFS_FILE_SB(file);
3823
3824 /* FIXME: set up handlers for larger reads and/or convert to async */
3825 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3826
3827 if (file->private_data == NULL) {
3828 rc = -EBADF;
3829 free_xid(xid);
3830 return rc;
3831 }
3832 open_file = file->private_data;
3833 tcon = tlink_tcon(open_file->tlink);
3834 server = tcon->ses->server;
3835
3836 if (!server->ops->sync_read) {
3837 free_xid(xid);
3838 return -ENOSYS;
3839 }
3840
3841 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3842 pid = open_file->pid;
3843 else
3844 pid = current->tgid;
3845
3846 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3847 cifs_dbg(FYI, "attempting read on write only file instance\n");
3848
3849 for (total_read = 0, cur_offset = read_data; read_size > total_read;
3850 total_read += bytes_read, cur_offset += bytes_read) {
3851 do {
3852 current_read_size = min_t(uint, read_size - total_read,
3853 rsize);
3854 /*
3855 * For windows me and 9x we do not want to request more
3856 * than it negotiated since it will refuse the read
3857 * then.
3858 */
3859 if ((tcon->ses) && !(tcon->ses->capabilities &
3860 tcon->ses->server->vals->cap_large_files)) {
3861 current_read_size = min_t(uint,
3862 current_read_size, CIFSMaxBufSize);
3863 }
3864 if (open_file->invalidHandle) {
3865 rc = cifs_reopen_file(open_file, true);
3866 if (rc != 0)
3867 break;
3868 }
3869 io_parms.pid = pid;
3870 io_parms.tcon = tcon;
3871 io_parms.offset = *offset;
3872 io_parms.length = current_read_size;
3873 rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3874 &bytes_read, &cur_offset,
3875 &buf_type);
3876 } while (rc == -EAGAIN);
3877
3878 if (rc || (bytes_read == 0)) {
3879 if (total_read) {
3880 break;
3881 } else {
3882 free_xid(xid);
3883 return rc;
3884 }
3885 } else {
3886 cifs_stats_bytes_read(tcon, total_read);
3887 *offset += bytes_read;
3888 }
3889 }
3890 free_xid(xid);
3891 return total_read;
3892 }
3893
3894 /*
3895 * If the page is mmap'ed into a process' page tables, then we need to make
3896 * sure that it doesn't change while being written back.
3897 */
3898 static vm_fault_t
3899 cifs_page_mkwrite(struct vm_fault *vmf)
3900 {
3901 struct page *page = vmf->page;
3902
3903 lock_page(page);
3904 return VM_FAULT_LOCKED;
3905 }
3906
3907 static const struct vm_operations_struct cifs_file_vm_ops = {
3908 .fault = filemap_fault,
3909 .map_pages = filemap_map_pages,
3910 .page_mkwrite = cifs_page_mkwrite,
3911 };
3912
3913 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3914 {
3915 int xid, rc = 0;
3916 struct inode *inode = file_inode(file);
3917
3918 xid = get_xid();
3919
3920 if (!CIFS_CACHE_READ(CIFS_I(inode)))
3921 rc = cifs_zap_mapping(inode);
3922 if (!rc)
3923 rc = generic_file_mmap(file, vma);
3924 if (!rc)
3925 vma->vm_ops = &cifs_file_vm_ops;
3926
3927 free_xid(xid);
3928 return rc;
3929 }
3930
3931 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3932 {
3933 int rc, xid;
3934
3935 xid = get_xid();
3936
3937 rc = cifs_revalidate_file(file);
3938 if (rc)
3939 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3940 rc);
3941 if (!rc)
3942 rc = generic_file_mmap(file, vma);
3943 if (!rc)
3944 vma->vm_ops = &cifs_file_vm_ops;
3945
3946 free_xid(xid);
3947 return rc;
3948 }
3949
3950 static void
3951 cifs_readv_complete(struct work_struct *work)
3952 {
3953 unsigned int i, got_bytes;
3954 struct cifs_readdata *rdata = container_of(work,
3955 struct cifs_readdata, work);
3956
3957 got_bytes = rdata->got_bytes;
3958 for (i = 0; i < rdata->nr_pages; i++) {
3959 struct page *page = rdata->pages[i];
3960
3961 lru_cache_add_file(page);
3962
3963 if (rdata->result == 0 ||
3964 (rdata->result == -EAGAIN && got_bytes)) {
3965 flush_dcache_page(page);
3966 SetPageUptodate(page);
3967 }
3968
3969 unlock_page(page);
3970
3971 if (rdata->result == 0 ||
3972 (rdata->result == -EAGAIN && got_bytes))
3973 cifs_readpage_to_fscache(rdata->mapping->host, page);
3974
3975 got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
3976
3977 put_page(page);
3978 rdata->pages[i] = NULL;
3979 }
3980 kref_put(&rdata->refcount, cifs_readdata_release);
3981 }
3982
3983 static int
3984 readpages_fill_pages(struct TCP_Server_Info *server,
3985 struct cifs_readdata *rdata, struct iov_iter *iter,
3986 unsigned int len)
3987 {
3988 int result = 0;
3989 unsigned int i;
3990 u64 eof;
3991 pgoff_t eof_index;
3992 unsigned int nr_pages = rdata->nr_pages;
3993 unsigned int page_offset = rdata->page_offset;
3994
3995 /* determine the eof that the server (probably) has */
3996 eof = CIFS_I(rdata->mapping->host)->server_eof;
3997 eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
3998 cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
3999
4000 rdata->got_bytes = 0;
4001 rdata->tailsz = PAGE_SIZE;
4002 for (i = 0; i < nr_pages; i++) {
4003 struct page *page = rdata->pages[i];
4004 unsigned int to_read = rdata->pagesz;
4005 size_t n;
4006
4007 if (i == 0)
4008 to_read -= page_offset;
4009 else
4010 page_offset = 0;
4011
4012 n = to_read;
4013
4014 if (len >= to_read) {
4015 len -= to_read;
4016 } else if (len > 0) {
4017 /* enough for partial page, fill and zero the rest */
4018 zero_user(page, len + page_offset, to_read - len);
4019 n = rdata->tailsz = len;
4020 len = 0;
4021 } else if (page->index > eof_index) {
4022 /*
4023 * The VFS will not try to do readahead past the
4024 * i_size, but it's possible that we have outstanding
4025 * writes with gaps in the middle and the i_size hasn't
4026 * caught up yet. Populate those with zeroed out pages
4027 * to prevent the VFS from repeatedly attempting to
4028 * fill them until the writes are flushed.
4029 */
4030 zero_user(page, 0, PAGE_SIZE);
4031 lru_cache_add_file(page);
4032 flush_dcache_page(page);
4033 SetPageUptodate(page);
4034 unlock_page(page);
4035 put_page(page);
4036 rdata->pages[i] = NULL;
4037 rdata->nr_pages--;
4038 continue;
4039 } else {
4040 /* no need to hold page hostage */
4041 lru_cache_add_file(page);
4042 unlock_page(page);
4043 put_page(page);
4044 rdata->pages[i] = NULL;
4045 rdata->nr_pages--;
4046 continue;
4047 }
4048
4049 if (iter)
4050 result = copy_page_from_iter(
4051 page, page_offset, n, iter);
4052 #ifdef CONFIG_CIFS_SMB_DIRECT
4053 else if (rdata->mr)
4054 result = n;
4055 #endif
4056 else
4057 result = cifs_read_page_from_socket(
4058 server, page, page_offset, n);
4059 if (result < 0)
4060 break;
4061
4062 rdata->got_bytes += result;
4063 }
4064
4065 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
4066 rdata->got_bytes : result;
4067 }
4068
4069 static int
4070 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
4071 struct cifs_readdata *rdata, unsigned int len)
4072 {
4073 return readpages_fill_pages(server, rdata, NULL, len);
4074 }
4075
4076 static int
4077 cifs_readpages_copy_into_pages(struct TCP_Server_Info *server,
4078 struct cifs_readdata *rdata,
4079 struct iov_iter *iter)
4080 {
4081 return readpages_fill_pages(server, rdata, iter, iter->count);
4082 }
4083
4084 static int
4085 readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
4086 unsigned int rsize, struct list_head *tmplist,
4087 unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
4088 {
4089 struct page *page, *tpage;
4090 unsigned int expected_index;
4091 int rc;
4092 gfp_t gfp = readahead_gfp_mask(mapping);
4093
4094 INIT_LIST_HEAD(tmplist);
4095
4096 page = lru_to_page(page_list);
4097
4098 /*
4099 * Lock the page and put it in the cache. Since no one else
4100 * should have access to this page, we're safe to simply set
4101 * PG_locked without checking it first.
4102 */
4103 __SetPageLocked(page);
4104 rc = add_to_page_cache_locked(page, mapping,
4105 page->index, gfp);
4106
4107 /* give up if we can't stick it in the cache */
4108 if (rc) {
4109 __ClearPageLocked(page);
4110 return rc;
4111 }
4112
4113 /* move first page to the tmplist */
4114 *offset = (loff_t)page->index << PAGE_SHIFT;
4115 *bytes = PAGE_SIZE;
4116 *nr_pages = 1;
4117 list_move_tail(&page->lru, tmplist);
4118
4119 /* now try and add more pages onto the request */
4120 expected_index = page->index + 1;
4121 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
4122 /* discontinuity ? */
4123 if (page->index != expected_index)
4124 break;
4125
4126 /* would this page push the read over the rsize? */
4127 if (*bytes + PAGE_SIZE > rsize)
4128 break;
4129
4130 __SetPageLocked(page);
4131 if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
4132 __ClearPageLocked(page);
4133 break;
4134 }
4135 list_move_tail(&page->lru, tmplist);
4136 (*bytes) += PAGE_SIZE;
4137 expected_index++;
4138 (*nr_pages)++;
4139 }
4140 return rc;
4141 }
4142
4143 static int cifs_readpages(struct file *file, struct address_space *mapping,
4144 struct list_head *page_list, unsigned num_pages)
4145 {
4146 int rc;
4147 struct list_head tmplist;
4148 struct cifsFileInfo *open_file = file->private_data;
4149 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
4150 struct TCP_Server_Info *server;
4151 pid_t pid;
4152 unsigned int xid;
4153
4154 xid = get_xid();
4155 /*
4156 * Reads as many pages as possible from fscache. Returns -ENOBUFS
4157 * immediately if the cookie is negative
4158 *
4159 * After this point, every page in the list might have PG_fscache set,
4160 * so we will need to clean that up off of every page we don't use.
4161 */
4162 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
4163 &num_pages);
4164 if (rc == 0) {
4165 free_xid(xid);
4166 return rc;
4167 }
4168
4169 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4170 pid = open_file->pid;
4171 else
4172 pid = current->tgid;
4173
4174 rc = 0;
4175 server = tlink_tcon(open_file->tlink)->ses->server;
4176
4177 cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
4178 __func__, file, mapping, num_pages);
4179
4180 /*
4181 * Start with the page at end of list and move it to private
4182 * list. Do the same with any following pages until we hit
4183 * the rsize limit, hit an index discontinuity, or run out of
4184 * pages. Issue the async read and then start the loop again
4185 * until the list is empty.
4186 *
4187 * Note that list order is important. The page_list is in
4188 * the order of declining indexes. When we put the pages in
4189 * the rdata->pages, then we want them in increasing order.
4190 */
4191 while (!list_empty(page_list)) {
4192 unsigned int i, nr_pages, bytes, rsize;
4193 loff_t offset;
4194 struct page *page, *tpage;
4195 struct cifs_readdata *rdata;
4196 struct cifs_credits credits_on_stack;
4197 struct cifs_credits *credits = &credits_on_stack;
4198
4199 if (open_file->invalidHandle) {
4200 rc = cifs_reopen_file(open_file, true);
4201 if (rc == -EAGAIN)
4202 continue;
4203 else if (rc)
4204 break;
4205 }
4206
4207 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
4208 &rsize, credits);
4209 if (rc)
4210 break;
4211
4212 /*
4213 * Give up immediately if rsize is too small to read an entire
4214 * page. The VFS will fall back to readpage. We should never
4215 * reach this point however since we set ra_pages to 0 when the
4216 * rsize is smaller than a cache page.
4217 */
4218 if (unlikely(rsize < PAGE_SIZE)) {
4219 add_credits_and_wake_if(server, credits, 0);
4220 free_xid(xid);
4221 return 0;
4222 }
4223
4224 rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
4225 &nr_pages, &offset, &bytes);
4226 if (rc) {
4227 add_credits_and_wake_if(server, credits, 0);
4228 break;
4229 }
4230
4231 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
4232 if (!rdata) {
4233 /* best to give up if we're out of mem */
4234 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4235 list_del(&page->lru);
4236 lru_cache_add_file(page);
4237 unlock_page(page);
4238 put_page(page);
4239 }
4240 rc = -ENOMEM;
4241 add_credits_and_wake_if(server, credits, 0);
4242 break;
4243 }
4244
4245 rdata->cfile = cifsFileInfo_get(open_file);
4246 rdata->mapping = mapping;
4247 rdata->offset = offset;
4248 rdata->bytes = bytes;
4249 rdata->pid = pid;
4250 rdata->pagesz = PAGE_SIZE;
4251 rdata->tailsz = PAGE_SIZE;
4252 rdata->read_into_pages = cifs_readpages_read_into_pages;
4253 rdata->copy_into_pages = cifs_readpages_copy_into_pages;
4254 rdata->credits = credits_on_stack;
4255
4256 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4257 list_del(&page->lru);
4258 rdata->pages[rdata->nr_pages++] = page;
4259 }
4260
4261 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4262
4263 if (!rc) {
4264 if (rdata->cfile->invalidHandle)
4265 rc = -EAGAIN;
4266 else
4267 rc = server->ops->async_readv(rdata);
4268 }
4269
4270 if (rc) {
4271 add_credits_and_wake_if(server, &rdata->credits, 0);
4272 for (i = 0; i < rdata->nr_pages; i++) {
4273 page = rdata->pages[i];
4274 lru_cache_add_file(page);
4275 unlock_page(page);
4276 put_page(page);
4277 }
4278 /* Fallback to the readpage in error/reconnect cases */
4279 kref_put(&rdata->refcount, cifs_readdata_release);
4280 break;
4281 }
4282
4283 kref_put(&rdata->refcount, cifs_readdata_release);
4284 }
4285
4286 /* Any pages that have been shown to fscache but didn't get added to
4287 * the pagecache must be uncached before they get returned to the
4288 * allocator.
4289 */
4290 cifs_fscache_readpages_cancel(mapping->host, page_list);
4291 free_xid(xid);
4292 return rc;
4293 }
4294
4295 /*
4296 * cifs_readpage_worker must be called with the page pinned
4297 */
4298 static int cifs_readpage_worker(struct file *file, struct page *page,
4299 loff_t *poffset)
4300 {
4301 char *read_data;
4302 int rc;
4303
4304 /* Is the page cached? */
4305 rc = cifs_readpage_from_fscache(file_inode(file), page);
4306 if (rc == 0)
4307 goto read_complete;
4308
4309 read_data = kmap(page);
4310 /* for reads over a certain size could initiate async read ahead */
4311
4312 rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
4313
4314 if (rc < 0)
4315 goto io_error;
4316 else
4317 cifs_dbg(FYI, "Bytes read %d\n", rc);
4318
4319 /* we do not want atime to be less than mtime, it broke some apps */
4320 file_inode(file)->i_atime = current_time(file_inode(file));
4321 if (timespec64_compare(&(file_inode(file)->i_atime), &(file_inode(file)->i_mtime)))
4322 file_inode(file)->i_atime = file_inode(file)->i_mtime;
4323 else
4324 file_inode(file)->i_atime = current_time(file_inode(file));
4325
4326 if (PAGE_SIZE > rc)
4327 memset(read_data + rc, 0, PAGE_SIZE - rc);
4328
4329 flush_dcache_page(page);
4330 SetPageUptodate(page);
4331
4332 /* send this page to the cache */
4333 cifs_readpage_to_fscache(file_inode(file), page);
4334
4335 rc = 0;
4336
4337 io_error:
4338 kunmap(page);
4339 unlock_page(page);
4340
4341 read_complete:
4342 return rc;
4343 }
4344
4345 static int cifs_readpage(struct file *file, struct page *page)
4346 {
4347 loff_t offset = (loff_t)page->index << PAGE_SHIFT;
4348 int rc = -EACCES;
4349 unsigned int xid;
4350
4351 xid = get_xid();
4352
4353 if (file->private_data == NULL) {
4354 rc = -EBADF;
4355 free_xid(xid);
4356 return rc;
4357 }
4358
4359 cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
4360 page, (int)offset, (int)offset);
4361
4362 rc = cifs_readpage_worker(file, page, &offset);
4363
4364 free_xid(xid);
4365 return rc;
4366 }
4367
4368 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
4369 {
4370 struct cifsFileInfo *open_file;
4371 struct cifs_tcon *tcon =
4372 cifs_sb_master_tcon(CIFS_SB(cifs_inode->vfs_inode.i_sb));
4373
4374 spin_lock(&tcon->open_file_lock);
4375 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
4376 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
4377 spin_unlock(&tcon->open_file_lock);
4378 return 1;
4379 }
4380 }
4381 spin_unlock(&tcon->open_file_lock);
4382 return 0;
4383 }
4384
4385 /* We do not want to update the file size from server for inodes
4386 open for write - to avoid races with writepage extending
4387 the file - in the future we could consider allowing
4388 refreshing the inode only on increases in the file size
4389 but this is tricky to do without racing with writebehind
4390 page caching in the current Linux kernel design */
4391 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
4392 {
4393 if (!cifsInode)
4394 return true;
4395
4396 if (is_inode_writable(cifsInode)) {
4397 /* This inode is open for write at least once */
4398 struct cifs_sb_info *cifs_sb;
4399
4400 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
4401 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
4402 /* since no page cache to corrupt on directio
4403 we can change size safely */
4404 return true;
4405 }
4406
4407 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
4408 return true;
4409
4410 return false;
4411 } else
4412 return true;
4413 }
4414
4415 static int cifs_write_begin(struct file *file, struct address_space *mapping,
4416 loff_t pos, unsigned len, unsigned flags,
4417 struct page **pagep, void **fsdata)
4418 {
4419 int oncethru = 0;
4420 pgoff_t index = pos >> PAGE_SHIFT;
4421 loff_t offset = pos & (PAGE_SIZE - 1);
4422 loff_t page_start = pos & PAGE_MASK;
4423 loff_t i_size;
4424 struct page *page;
4425 int rc = 0;
4426
4427 cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
4428
4429 start:
4430 page = grab_cache_page_write_begin(mapping, index, flags);
4431 if (!page) {
4432 rc = -ENOMEM;
4433 goto out;
4434 }
4435
4436 if (PageUptodate(page))
4437 goto out;
4438
4439 /*
4440 * If we write a full page it will be up to date, no need to read from
4441 * the server. If the write is short, we'll end up doing a sync write
4442 * instead.
4443 */
4444 if (len == PAGE_SIZE)
4445 goto out;
4446
4447 /*
4448 * optimize away the read when we have an oplock, and we're not
4449 * expecting to use any of the data we'd be reading in. That
4450 * is, when the page lies beyond the EOF, or straddles the EOF
4451 * and the write will cover all of the existing data.
4452 */
4453 if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
4454 i_size = i_size_read(mapping->host);
4455 if (page_start >= i_size ||
4456 (offset == 0 && (pos + len) >= i_size)) {
4457 zero_user_segments(page, 0, offset,
4458 offset + len,
4459 PAGE_SIZE);
4460 /*
4461 * PageChecked means that the parts of the page
4462 * to which we're not writing are considered up
4463 * to date. Once the data is copied to the
4464 * page, it can be set uptodate.
4465 */
4466 SetPageChecked(page);
4467 goto out;
4468 }
4469 }
4470
4471 if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
4472 /*
4473 * might as well read a page, it is fast enough. If we get
4474 * an error, we don't need to return it. cifs_write_end will
4475 * do a sync write instead since PG_uptodate isn't set.
4476 */
4477 cifs_readpage_worker(file, page, &page_start);
4478 put_page(page);
4479 oncethru = 1;
4480 goto start;
4481 } else {
4482 /* we could try using another file handle if there is one -
4483 but how would we lock it to prevent close of that handle
4484 racing with this read? In any case
4485 this will be written out by write_end so is fine */
4486 }
4487 out:
4488 *pagep = page;
4489 return rc;
4490 }
4491
4492 static int cifs_release_page(struct page *page, gfp_t gfp)
4493 {
4494 if (PagePrivate(page))
4495 return 0;
4496
4497 return cifs_fscache_release_page(page, gfp);
4498 }
4499
4500 static void cifs_invalidate_page(struct page *page, unsigned int offset,
4501 unsigned int length)
4502 {
4503 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
4504
4505 if (offset == 0 && length == PAGE_SIZE)
4506 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
4507 }
4508
4509 static int cifs_launder_page(struct page *page)
4510 {
4511 int rc = 0;
4512 loff_t range_start = page_offset(page);
4513 loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
4514 struct writeback_control wbc = {
4515 .sync_mode = WB_SYNC_ALL,
4516 .nr_to_write = 0,
4517 .range_start = range_start,
4518 .range_end = range_end,
4519 };
4520
4521 cifs_dbg(FYI, "Launder page: %p\n", page);
4522
4523 if (clear_page_dirty_for_io(page))
4524 rc = cifs_writepage_locked(page, &wbc);
4525
4526 cifs_fscache_invalidate_page(page, page->mapping->host);
4527 return rc;
4528 }
4529
4530 void cifs_oplock_break(struct work_struct *work)
4531 {
4532 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
4533 oplock_break);
4534 struct inode *inode = d_inode(cfile->dentry);
4535 struct cifsInodeInfo *cinode = CIFS_I(inode);
4536 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4537 struct TCP_Server_Info *server = tcon->ses->server;
4538 int rc = 0;
4539
4540 wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
4541 TASK_UNINTERRUPTIBLE);
4542
4543 server->ops->downgrade_oplock(server, cinode,
4544 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, &cinode->flags));
4545
4546 if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
4547 cifs_has_mand_locks(cinode)) {
4548 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
4549 inode);
4550 cinode->oplock = 0;
4551 }
4552
4553 if (inode && S_ISREG(inode->i_mode)) {
4554 if (CIFS_CACHE_READ(cinode))
4555 break_lease(inode, O_RDONLY);
4556 else
4557 break_lease(inode, O_WRONLY);
4558 rc = filemap_fdatawrite(inode->i_mapping);
4559 if (!CIFS_CACHE_READ(cinode)) {
4560 rc = filemap_fdatawait(inode->i_mapping);
4561 mapping_set_error(inode->i_mapping, rc);
4562 cifs_zap_mapping(inode);
4563 }
4564 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
4565 }
4566
4567 rc = cifs_push_locks(cfile);
4568 if (rc)
4569 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
4570
4571 /*
4572 * releasing stale oplock after recent reconnect of smb session using
4573 * a now incorrect file handle is not a data integrity issue but do
4574 * not bother sending an oplock release if session to server still is
4575 * disconnected since oplock already released by the server
4576 */
4577 if (!cfile->oplock_break_cancelled) {
4578 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
4579 cinode);
4580 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
4581 }
4582 cifs_done_oplock_break(cinode);
4583 }
4584
4585 /*
4586 * The presence of cifs_direct_io() in the address space ops vector
4587 * allowes open() O_DIRECT flags which would have failed otherwise.
4588 *
4589 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
4590 * so this method should never be called.
4591 *
4592 * Direct IO is not yet supported in the cached mode.
4593 */
4594 static ssize_t
4595 cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
4596 {
4597 /*
4598 * FIXME
4599 * Eventually need to support direct IO for non forcedirectio mounts
4600 */
4601 return -EINVAL;
4602 }
4603
4604
4605 const struct address_space_operations cifs_addr_ops = {
4606 .readpage = cifs_readpage,
4607 .readpages = cifs_readpages,
4608 .writepage = cifs_writepage,
4609 .writepages = cifs_writepages,
4610 .write_begin = cifs_write_begin,
4611 .write_end = cifs_write_end,
4612 .set_page_dirty = __set_page_dirty_nobuffers,
4613 .releasepage = cifs_release_page,
4614 .direct_IO = cifs_direct_io,
4615 .invalidatepage = cifs_invalidate_page,
4616 .launder_page = cifs_launder_page,
4617 };
4618
4619 /*
4620 * cifs_readpages requires the server to support a buffer large enough to
4621 * contain the header plus one complete page of data. Otherwise, we need
4622 * to leave cifs_readpages out of the address space operations.
4623 */
4624 const struct address_space_operations cifs_addr_ops_smallbuf = {
4625 .readpage = cifs_readpage,
4626 .writepage = cifs_writepage,
4627 .writepages = cifs_writepages,
4628 .write_begin = cifs_write_begin,
4629 .write_end = cifs_write_end,
4630 .set_page_dirty = __set_page_dirty_nobuffers,
4631 .releasepage = cifs_release_page,
4632 .invalidatepage = cifs_invalidate_page,
4633 .launder_page = cifs_launder_page,
4634 };
Ubuntu Jammy Linux kernel mirror