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