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