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