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