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