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