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