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