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