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