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