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