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