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