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