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