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