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