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