projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cifs: add wrapper for cifs_async_readv to retry opening file
[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);
0471ca3f
JL		 2351 INIT_WORK(&rdata->work, complete);
2352 INIT_LIST_HEAD(&rdata->pages);
2353 }
2354 return rdata;
2355}
2356
6993f74a
JL		 2357void
2358cifs_readdata_release(struct kref *refcount)
0471ca3f 2359{
6993f74a
JL		 2360 struct cifs_readdata *rdata = container_of(refcount,
2361 struct cifs_readdata, refcount);
2362
2363 if (rdata->cfile)
2364 cifsFileInfo_put(rdata->cfile);
2365
0471ca3f
JL		 2366 kfree(rdata);
2367}
2368
2a1bb138
JL		 2369static int
2370cifs_retry_async_readv(struct cifs_readdata *rdata)
2371{
2372 int rc;
2373
2374 do {
2375 if (rdata->cfile->invalidHandle) {
2376 rc = cifs_reopen_file(rdata->cfile, true);
2377 if (rc != 0)
2378 continue;
2379 }
2380 rc = cifs_async_readv(rdata);
2381 } while (rc == -EAGAIN);
2382
2383 return rc;
2384}
2385
a70307ee
PS		 2386static ssize_t
2387cifs_iovec_read(struct file *file, const struct iovec *iov,
2388 unsigned long nr_segs, loff_t *poffset)
1da177e4 2389{
a70307ee
PS		 2390 int rc;
2391 int xid;
76429c14
PS		 2392 ssize_t total_read;
2393 unsigned int bytes_read = 0;
a70307ee
PS		 2394 size_t len, cur_len;
2395 int iov_offset = 0;
1da177e4 2396 struct cifs_sb_info *cifs_sb;
96daf2b0 2397 struct cifs_tcon *pTcon;
1da177e4 2398 struct cifsFileInfo *open_file;
1da177e4 2399 struct smb_com_read_rsp *pSMBr;
d4ffff1f 2400 struct cifs_io_parms io_parms;
a70307ee 2401 char *read_data;
5eba8ab3 2402 unsigned int rsize;
d4ffff1f 2403 __u32 pid;
a70307ee
PS		 2404
2405 if (!nr_segs)
2406 return 0;
2407
2408 len = iov_length(iov, nr_segs);
2409 if (!len)
2410 return 0;
1da177e4
LT		 2411
2412 xid = GetXid();
e6a00296 2413 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1da177e4 2414
5eba8ab3
JL		 2415 /* FIXME: set up handlers for larger reads and/or convert to async */
2416 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2417
c21dfb69 2418 open_file = file->private_data;
13cfb733 2419 pTcon = tlink_tcon(open_file->tlink);
1da177e4 2420
d4ffff1f
PS		 2421 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2422 pid = open_file->pid;
2423 else
2424 pid = current->tgid;
2425
ad7a2926 2426 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
b6b38f70 2427 cFYI(1, "attempting read on write only file instance");
ad7a2926 2428
a70307ee 2429 for (total_read = 0; total_read < len; total_read += bytes_read) {
5eba8ab3 2430 cur_len = min_t(const size_t, len - total_read, rsize);
1da177e4 2431 rc = -EAGAIN;
a70307ee
PS		 2432 read_data = NULL;
2433
1da177e4 2434 while (rc == -EAGAIN) {
ec637e3f 2435 int buf_type = CIFS_NO_BUFFER;
cdff08e7 2436 if (open_file->invalidHandle) {
15886177 2437 rc = cifs_reopen_file(open_file, true);
1da177e4
LT		 2438 if (rc != 0)
2439 break;
2440 }
d4ffff1f
PS		 2441 io_parms.netfid = open_file->netfid;
2442 io_parms.pid = pid;
2443 io_parms.tcon = pTcon;
2444 io_parms.offset = *poffset;
2cebaa58 2445 io_parms.length = cur_len;
d4ffff1f 2446 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
a70307ee
PS		 2447 &read_data, &buf_type);
2448 pSMBr = (struct smb_com_read_rsp *)read_data;
2449 if (read_data) {
2450 char *data_offset = read_data + 4 +
2451 le16_to_cpu(pSMBr->DataOffset);
2452 if (memcpy_toiovecend(iov, data_offset,
2453 iov_offset, bytes_read))
93544cc6 2454 rc = -EFAULT;
fb8c4b14 2455 if (buf_type == CIFS_SMALL_BUFFER)
a70307ee 2456 cifs_small_buf_release(read_data);
fb8c4b14 2457 else if (buf_type == CIFS_LARGE_BUFFER)
a70307ee
PS		 2458 cifs_buf_release(read_data);
2459 read_data = NULL;
2460 iov_offset += bytes_read;
1da177e4
LT		 2461 }
2462 }
a70307ee 2463
1da177e4
LT		 2464 if (rc || (bytes_read == 0)) {
2465 if (total_read) {
2466 break;
2467 } else {
2468 FreeXid(xid);
2469 return rc;
2470 }
2471 } else {
a4544347 2472 cifs_stats_bytes_read(pTcon, bytes_read);
1da177e4
LT		 2473 *poffset += bytes_read;
2474 }
2475 }
a70307ee 2476
1da177e4
LT		 2477 FreeXid(xid);
2478 return total_read;
2479}
2480
0b81c1c4 2481ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
a70307ee
PS		 2482 unsigned long nr_segs, loff_t pos)
2483{
2484 ssize_t read;
2485
2486 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2487 if (read > 0)
2488 iocb->ki_pos = pos;
2489
2490 return read;
2491}
2492
2493ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2494 unsigned long nr_segs, loff_t pos)
2495{
2496 struct inode *inode;
2497
2498 inode = iocb->ki_filp->f_path.dentry->d_inode;
2499
2500 if (CIFS_I(inode)->clientCanCacheRead)
2501 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2502
2503 /*
2504 * In strict cache mode we need to read from the server all the time
2505 * if we don't have level II oplock because the server can delay mtime
2506 * change - so we can't make a decision about inode invalidating.
2507 * And we can also fail with pagereading if there are mandatory locks
2508 * on pages affected by this read but not on the region from pos to
2509 * pos+len-1.
2510 */
2511
2512 return cifs_user_readv(iocb, iov, nr_segs, pos);
2513}
1da177e4
LT		 2514
2515static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
a70307ee 2516 loff_t *poffset)
1da177e4
LT		 2517{
2518 int rc = -EACCES;
2519 unsigned int bytes_read = 0;
2520 unsigned int total_read;
2521 unsigned int current_read_size;
5eba8ab3 2522 unsigned int rsize;
1da177e4 2523 struct cifs_sb_info *cifs_sb;
96daf2b0 2524 struct cifs_tcon *pTcon;
1da177e4
LT		 2525 int xid;
2526 char *current_offset;
2527 struct cifsFileInfo *open_file;
d4ffff1f 2528 struct cifs_io_parms io_parms;
ec637e3f 2529 int buf_type = CIFS_NO_BUFFER;
d4ffff1f 2530 __u32 pid;
1da177e4
LT		 2531
2532 xid = GetXid();
e6a00296 2533 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1da177e4 2534
5eba8ab3
JL		 2535 /* FIXME: set up handlers for larger reads and/or convert to async */
2536 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2537
1da177e4 2538 if (file->private_data == NULL) {
0f3bc09e 2539 rc = -EBADF;
1da177e4 2540 FreeXid(xid);
0f3bc09e 2541 return rc;
1da177e4 2542 }
c21dfb69 2543 open_file = file->private_data;
13cfb733 2544 pTcon = tlink_tcon(open_file->tlink);
1da177e4 2545
d4ffff1f
PS		 2546 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2547 pid = open_file->pid;
2548 else
2549 pid = current->tgid;
2550
1da177e4 2551 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
b6b38f70 2552 cFYI(1, "attempting read on write only file instance");
1da177e4 2553
fb8c4b14 2554 for (total_read = 0, current_offset = read_data;
1da177e4
LT		 2555 read_size > total_read;
2556 total_read += bytes_read, current_offset += bytes_read) {
5eba8ab3
JL		 2557 current_read_size = min_t(uint, read_size - total_read, rsize);
2558
f9f5c817
SF		 2559 /* For windows me and 9x we do not want to request more
2560 than it negotiated since it will refuse the read then */
fb8c4b14 2561 if ((pTcon->ses) &&
f9f5c817 2562 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
7748dd6e 2563 current_read_size = min_t(uint, current_read_size,
c974befa 2564 CIFSMaxBufSize);
f9f5c817 2565 }
1da177e4
LT		 2566 rc = -EAGAIN;
2567 while (rc == -EAGAIN) {
cdff08e7 2568 if (open_file->invalidHandle) {
15886177 2569 rc = cifs_reopen_file(open_file, true);
1da177e4
LT		 2570 if (rc != 0)
2571 break;
2572 }
d4ffff1f
PS		 2573 io_parms.netfid = open_file->netfid;
2574 io_parms.pid = pid;
2575 io_parms.tcon = pTcon;
2576 io_parms.offset = *poffset;
2577 io_parms.length = current_read_size;
2578 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2579 &current_offset, &buf_type);
1da177e4
LT		 2580 }
2581 if (rc || (bytes_read == 0)) {
2582 if (total_read) {
2583 break;
2584 } else {
2585 FreeXid(xid);
2586 return rc;
2587 }
2588 } else {
a4544347 2589 cifs_stats_bytes_read(pTcon, total_read);
1da177e4
LT		 2590 *poffset += bytes_read;
2591 }
2592 }
2593 FreeXid(xid);
2594 return total_read;
2595}
2596
ca83ce3d
JL		 2597/*
2598 * If the page is mmap'ed into a process' page tables, then we need to make
2599 * sure that it doesn't change while being written back.
2600 */
2601static int
2602cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2603{
2604 struct page *page = vmf->page;
2605
2606 lock_page(page);
2607 return VM_FAULT_LOCKED;
2608}
2609
2610static struct vm_operations_struct cifs_file_vm_ops = {
2611 .fault = filemap_fault,
2612 .page_mkwrite = cifs_page_mkwrite,
2613};
2614
7a6a19b1
PS		 2615int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2616{
2617 int rc, xid;
2618 struct inode *inode = file->f_path.dentry->d_inode;
2619
2620 xid = GetXid();
2621
6feb9891
PS		 2622 if (!CIFS_I(inode)->clientCanCacheRead) {
2623 rc = cifs_invalidate_mapping(inode);
2624 if (rc)
2625 return rc;
2626 }
7a6a19b1
PS		 2627
2628 rc = generic_file_mmap(file, vma);
ca83ce3d
JL		 2629 if (rc == 0)
2630 vma->vm_ops = &cifs_file_vm_ops;
7a6a19b1
PS		 2631 FreeXid(xid);
2632 return rc;
2633}
2634
1da177e4
LT		 2635int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2636{
1da177e4
LT		 2637 int rc, xid;
2638
2639 xid = GetXid();
abab095d 2640 rc = cifs_revalidate_file(file);
1da177e4 2641 if (rc) {
b6b38f70 2642 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
1da177e4
LT		 2643 FreeXid(xid);
2644 return rc;
2645 }
2646 rc = generic_file_mmap(file, vma);
ca83ce3d
JL		 2647 if (rc == 0)
2648 vma->vm_ops = &cifs_file_vm_ops;
1da177e4
LT		 2649 FreeXid(xid);
2650 return rc;
2651}
2652
0471ca3f
JL		 2653static void
2654cifs_readv_complete(struct work_struct *work)
2655{
2656 struct cifs_readdata *rdata = container_of(work,
2657 struct cifs_readdata, work);
2658 struct page *page, *tpage;
2659
2660 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
2661 list_del(&page->lru);
2662 lru_cache_add_file(page);
2663
2664 if (rdata->result == 0) {
2665 kunmap(page);
2666 flush_dcache_page(page);
2667 SetPageUptodate(page);
2668 }
2669
2670 unlock_page(page);
2671
2672 if (rdata->result == 0)
2673 cifs_readpage_to_fscache(rdata->mapping->host, page);
2674
2675 page_cache_release(page);
2676 }
6993f74a 2677 kref_put(&rdata->refcount, cifs_readdata_release);
0471ca3f
JL		 2678}
2679
8d5ce4d2
JL		 2680static int
2681cifs_readpages_marshal_iov(struct cifs_readdata *rdata, unsigned int remaining)
2682{
2683 int len = 0;
2684 struct page *page, *tpage;
2685 u64 eof;
2686 pgoff_t eof_index;
2687
2688 /* determine the eof that the server (probably) has */
2689 eof = CIFS_I(rdata->mapping->host)->server_eof;
2690 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
2691 cFYI(1, "eof=%llu eof_index=%lu", eof, eof_index);
2692
2693 rdata->nr_iov = 1;
2694 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
2695 if (remaining >= PAGE_CACHE_SIZE) {
2696 /* enough data to fill the page */
2697 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
2698 rdata->iov[rdata->nr_iov].iov_len = PAGE_CACHE_SIZE;
2699 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2700 rdata->nr_iov, page->index,
2701 rdata->iov[rdata->nr_iov].iov_base,
2702 rdata->iov[rdata->nr_iov].iov_len);
2703 ++rdata->nr_iov;
2704 len += PAGE_CACHE_SIZE;
2705 remaining -= PAGE_CACHE_SIZE;
2706 } else if (remaining > 0) {
2707 /* enough for partial page, fill and zero the rest */
2708 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
2709 rdata->iov[rdata->nr_iov].iov_len = remaining;
2710 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2711 rdata->nr_iov, page->index,
2712 rdata->iov[rdata->nr_iov].iov_base,
2713 rdata->iov[rdata->nr_iov].iov_len);
2714 memset(rdata->iov[rdata->nr_iov].iov_base + remaining,
2715 '\0', PAGE_CACHE_SIZE - remaining);
2716 ++rdata->nr_iov;
2717 len += remaining;
2718 remaining = 0;
2719 } else if (page->index > eof_index) {
2720 /*
2721 * The VFS will not try to do readahead past the
2722 * i_size, but it's possible that we have outstanding
2723 * writes with gaps in the middle and the i_size hasn't
2724 * caught up yet. Populate those with zeroed out pages
2725 * to prevent the VFS from repeatedly attempting to
2726 * fill them until the writes are flushed.
2727 */
2728 zero_user(page, 0, PAGE_CACHE_SIZE);
2729 list_del(&page->lru);
2730 lru_cache_add_file(page);
2731 flush_dcache_page(page);
2732 SetPageUptodate(page);
2733 unlock_page(page);
2734 page_cache_release(page);
2735 } else {
2736 /* no need to hold page hostage */
2737 list_del(&page->lru);
2738 lru_cache_add_file(page);
2739 unlock_page(page);
2740 page_cache_release(page);
2741 }
2742 }
2743
2744 return len;
2745}
2746
1da177e4
LT		 2747static int cifs_readpages(struct file *file, struct address_space *mapping,
2748 struct list_head *page_list, unsigned num_pages)
2749{
690c5e31
JL		 2750 int rc;
2751 struct list_head tmplist;
2752 struct cifsFileInfo *open_file = file->private_data;
2753 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2754 unsigned int rsize = cifs_sb->rsize;
2755 pid_t pid;
1da177e4 2756
690c5e31
JL		 2757 /*
2758 * Give up immediately if rsize is too small to read an entire page.
2759 * The VFS will fall back to readpage. We should never reach this
2760 * point however since we set ra_pages to 0 when the rsize is smaller
2761 * than a cache page.
2762 */
2763 if (unlikely(rsize < PAGE_CACHE_SIZE))
2764 return 0;
bfa0d75a 2765
56698236
SJ		 2766 /*
2767 * Reads as many pages as possible from fscache. Returns -ENOBUFS
2768 * immediately if the cookie is negative
2769 */
2770 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2771 &num_pages);
2772 if (rc == 0)
690c5e31 2773 return rc;
56698236 2774
d4ffff1f
PS		 2775 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2776 pid = open_file->pid;
2777 else
2778 pid = current->tgid;
2779
690c5e31
JL		 2780 rc = 0;
2781 INIT_LIST_HEAD(&tmplist);
1da177e4 2782
690c5e31
JL		 2783 cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2784 mapping, num_pages);
2785
2786 /*
2787 * Start with the page at end of list and move it to private
2788 * list. Do the same with any following pages until we hit
2789 * the rsize limit, hit an index discontinuity, or run out of
2790 * pages. Issue the async read and then start the loop again
2791 * until the list is empty.
2792 *
2793 * Note that list order is important. The page_list is in
2794 * the order of declining indexes. When we put the pages in
2795 * the rdata->pages, then we want them in increasing order.
2796 */
2797 while (!list_empty(page_list)) {
2798 unsigned int bytes = PAGE_CACHE_SIZE;
2799 unsigned int expected_index;
2800 unsigned int nr_pages = 1;
2801 loff_t offset;
2802 struct page *page, *tpage;
2803 struct cifs_readdata *rdata;
1da177e4
LT		 2804
2805 page = list_entry(page_list->prev, struct page, lru);
690c5e31
JL		 2806
2807 /*
2808 * Lock the page and put it in the cache. Since no one else
2809 * should have access to this page, we're safe to simply set
2810 * PG_locked without checking it first.
2811 */
2812 __set_page_locked(page);
2813 rc = add_to_page_cache_locked(page, mapping,
2814 page->index, GFP_KERNEL);
2815
2816 /* give up if we can't stick it in the cache */
2817 if (rc) {
2818 __clear_page_locked(page);
2819 break;
2820 }
2821
2822 /* move first page to the tmplist */
1da177e4 2823 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
690c5e31 2824 list_move_tail(&page->lru, &tmplist);
1da177e4 2825
690c5e31
JL		 2826 /* now try and add more pages onto the request */
2827 expected_index = page->index + 1;
2828 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2829 /* discontinuity ? */
2830 if (page->index != expected_index)
fb8c4b14 2831 break;
690c5e31
JL		 2832
2833 /* would this page push the read over the rsize? */
2834 if (bytes + PAGE_CACHE_SIZE > rsize)
2835 break;
2836
2837 __set_page_locked(page);
2838 if (add_to_page_cache_locked(page, mapping,
2839 page->index, GFP_KERNEL)) {
2840 __clear_page_locked(page);
2841 break;
2842 }
2843 list_move_tail(&page->lru, &tmplist);
2844 bytes += PAGE_CACHE_SIZE;
2845 expected_index++;
2846 nr_pages++;
1da177e4 2847 }
690c5e31 2848
0471ca3f 2849 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
690c5e31
JL		 2850 if (!rdata) {
2851 /* best to give up if we're out of mem */
2852 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2853 list_del(&page->lru);
2854 lru_cache_add_file(page);
2855 unlock_page(page);
2856 page_cache_release(page);
2857 }
2858 rc = -ENOMEM;
2859 break;
2860 }
2861
2862 spin_lock(&cifs_file_list_lock);
690c5e31 2863 spin_unlock(&cifs_file_list_lock);
6993f74a 2864 rdata->cfile = cifsFileInfo_get(open_file);
690c5e31
JL		 2865 rdata->mapping = mapping;
2866 rdata->offset = offset;
2867 rdata->bytes = bytes;
2868 rdata->pid = pid;
8d5ce4d2 2869 rdata->marshal_iov = cifs_readpages_marshal_iov;
690c5e31
JL		 2870 list_splice_init(&tmplist, &rdata->pages);
2871
2a1bb138 2872 rc = cifs_retry_async_readv(rdata);
690c5e31
JL		 2873 if (rc != 0) {
2874 list_for_each_entry_safe(page, tpage, &rdata->pages,
2875 lru) {
2876 list_del(&page->lru);
2877 lru_cache_add_file(page);
2878 unlock_page(page);
2879 page_cache_release(page);
1da177e4 2880 }
6993f74a 2881 kref_put(&rdata->refcount, cifs_readdata_release);
1da177e4
LT		 2882 break;
2883 }
6993f74a
JL		 2884
2885 kref_put(&rdata->refcount, cifs_readdata_release);
1da177e4
LT		 2886 }
2887
1da177e4
LT		 2888 return rc;
2889}
2890
2891static int cifs_readpage_worker(struct file *file, struct page *page,
2892 loff_t *poffset)
2893{
2894 char *read_data;
2895 int rc;
2896
56698236
SJ		 2897 /* Is the page cached? */
2898 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2899 if (rc == 0)
2900 goto read_complete;
2901
1da177e4
LT		 2902 page_cache_get(page);
2903 read_data = kmap(page);
2904 /* for reads over a certain size could initiate async read ahead */
fb8c4b14 2905
1da177e4 2906 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
fb8c4b14 2907
1da177e4
LT		 2908 if (rc < 0)
2909 goto io_error;
2910 else
b6b38f70 2911 cFYI(1, "Bytes read %d", rc);
fb8c4b14 2912
e6a00296
JJS		 2913 file->f_path.dentry->d_inode->i_atime =
2914 current_fs_time(file->f_path.dentry->d_inode->i_sb);
fb8c4b14 2915
1da177e4
LT		 2916 if (PAGE_CACHE_SIZE > rc)
2917 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2918
2919 flush_dcache_page(page);
2920 SetPageUptodate(page);
9dc06558
SJ		 2921
2922 /* send this page to the cache */
2923 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2924
1da177e4 2925 rc = 0;
fb8c4b14 2926
1da177e4 2927io_error:
fb8c4b14 2928 kunmap(page);
1da177e4 2929 page_cache_release(page);
56698236
SJ		 2930
2931read_complete:
1da177e4
LT		 2932 return rc;
2933}
2934
2935static int cifs_readpage(struct file *file, struct page *page)
2936{
2937 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2938 int rc = -EACCES;
2939 int xid;
2940
2941 xid = GetXid();
2942
2943 if (file->private_data == NULL) {
0f3bc09e 2944 rc = -EBADF;
1da177e4 2945 FreeXid(xid);
0f3bc09e 2946 return rc;
1da177e4
LT		 2947 }
2948
b6b38f70
JP		 2949 cFYI(1, "readpage %p at offset %d 0x%x\n",
2950 page, (int)offset, (int)offset);
1da177e4
LT		 2951
2952 rc = cifs_readpage_worker(file, page, &offset);
2953
2954 unlock_page(page);
2955
2956 FreeXid(xid);
2957 return rc;
2958}
2959
a403a0a3
SF		 2960static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2961{
2962 struct cifsFileInfo *open_file;
2963
4477288a 2964 spin_lock(&cifs_file_list_lock);
a403a0a3 2965 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2e396b83 2966 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
4477288a 2967 spin_unlock(&cifs_file_list_lock);
a403a0a3
SF		 2968 return 1;
2969 }
2970 }
4477288a 2971 spin_unlock(&cifs_file_list_lock);
a403a0a3
SF		 2972 return 0;
2973}
2974
1da177e4
LT		 2975/* We do not want to update the file size from server for inodes
2976 open for write - to avoid races with writepage extending
2977 the file - in the future we could consider allowing
fb8c4b14 2978 refreshing the inode only on increases in the file size
1da177e4
LT		 2979 but this is tricky to do without racing with writebehind
2980 page caching in the current Linux kernel design */
4b18f2a9 2981bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
1da177e4 2982{
a403a0a3 2983 if (!cifsInode)
4b18f2a9 2984 return true;
50c2f753 2985
a403a0a3
SF		 2986 if (is_inode_writable(cifsInode)) {
2987 /* This inode is open for write at least once */
c32a0b68
SF		 2988 struct cifs_sb_info *cifs_sb;
2989
c32a0b68 2990 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
ad7a2926 2991 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
fb8c4b14 2992 /* since no page cache to corrupt on directio
c32a0b68 2993 we can change size safely */
4b18f2a9 2994 return true;
c32a0b68
SF		 2995 }
2996
fb8c4b14 2997 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
4b18f2a9 2998 return true;
7ba52631 2999
4b18f2a9 3000 return false;
23e7dd7d 3001 } else
4b18f2a9 3002 return true;
1da177e4
LT		 3003}
3004
d9414774
NP		 3005static int cifs_write_begin(struct file *file, struct address_space *mapping,
3006 loff_t pos, unsigned len, unsigned flags,
3007 struct page **pagep, void **fsdata)
1da177e4 3008{
d9414774
NP		 3009 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3010 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
a98ee8c1
JL		 3011 loff_t page_start = pos & PAGE_MASK;
3012 loff_t i_size;
3013 struct page *page;
3014 int rc = 0;
d9414774 3015
b6b38f70 3016 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
d9414774 3017
54566b2c 3018 page = grab_cache_page_write_begin(mapping, index, flags);
a98ee8c1
JL		 3019 if (!page) {
3020 rc = -ENOMEM;
3021 goto out;
3022 }
8a236264 3023
a98ee8c1
JL		 3024 if (PageUptodate(page))
3025 goto out;
8a236264 3026
a98ee8c1
JL		 3027 /*
3028 * If we write a full page it will be up to date, no need to read from
3029 * the server. If the write is short, we'll end up doing a sync write
3030 * instead.
3031 */
3032 if (len == PAGE_CACHE_SIZE)
3033 goto out;
8a236264 3034
a98ee8c1
JL		 3035 /*
3036 * optimize away the read when we have an oplock, and we're not
3037 * expecting to use any of the data we'd be reading in. That
3038 * is, when the page lies beyond the EOF, or straddles the EOF
3039 * and the write will cover all of the existing data.
3040 */
3041 if (CIFS_I(mapping->host)->clientCanCacheRead) {
3042 i_size = i_size_read(mapping->host);
3043 if (page_start >= i_size ||
3044 (offset == 0 && (pos + len) >= i_size)) {
3045 zero_user_segments(page, 0, offset,
3046 offset + len,
3047 PAGE_CACHE_SIZE);
3048 /*
3049 * PageChecked means that the parts of the page
3050 * to which we're not writing are considered up
3051 * to date. Once the data is copied to the
3052 * page, it can be set uptodate.
3053 */
3054 SetPageChecked(page);
3055 goto out;
3056 }
3057 }
d9414774 3058
a98ee8c1
JL		 3059 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
3060 /*
3061 * might as well read a page, it is fast enough. If we get
3062 * an error, we don't need to return it. cifs_write_end will
3063 * do a sync write instead since PG_uptodate isn't set.
3064 */
3065 cifs_readpage_worker(file, page, &page_start);
8a236264
SF		 3066 } else {
3067 /* we could try using another file handle if there is one -
3068 but how would we lock it to prevent close of that handle
3069 racing with this read? In any case
d9414774 3070 this will be written out by write_end so is fine */
1da177e4 3071 }
a98ee8c1
JL		 3072out:
3073 *pagep = page;
3074 return rc;
1da177e4
LT		 3075}
3076
85f2d6b4
SJ		 3077static int cifs_release_page(struct page *page, gfp_t gfp)
3078{
3079 if (PagePrivate(page))
3080 return 0;
3081
3082 return cifs_fscache_release_page(page, gfp);
3083}
3084
3085static void cifs_invalidate_page(struct page *page, unsigned long offset)
3086{
3087 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3088
3089 if (offset == 0)
3090 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3091}
3092
9ad1506b
PS		 3093static int cifs_launder_page(struct page *page)
3094{
3095 int rc = 0;
3096 loff_t range_start = page_offset(page);
3097 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3098 struct writeback_control wbc = {
3099 .sync_mode = WB_SYNC_ALL,
3100 .nr_to_write = 0,
3101 .range_start = range_start,
3102 .range_end = range_end,
3103 };
3104
3105 cFYI(1, "Launder page: %p", page);
3106
3107 if (clear_page_dirty_for_io(page))
3108 rc = cifs_writepage_locked(page, &wbc);
3109
3110 cifs_fscache_invalidate_page(page, page->mapping->host);
3111 return rc;
3112}
3113
9b646972 3114void cifs_oplock_break(struct work_struct *work)
3bc303c2
JL		 3115{
3116 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3117 oplock_break);
a5e18bc3 3118 struct inode *inode = cfile->dentry->d_inode;
3bc303c2 3119 struct cifsInodeInfo *cinode = CIFS_I(inode);
eb4b756b 3120 int rc = 0;
3bc303c2
JL		 3121
3122 if (inode && S_ISREG(inode->i_mode)) {
d54ff732 3123 if (cinode->clientCanCacheRead)
8737c930 3124 break_lease(inode, O_RDONLY);
d54ff732 3125 else
8737c930 3126 break_lease(inode, O_WRONLY);
3bc303c2
JL		 3127 rc = filemap_fdatawrite(inode->i_mapping);
3128 if (cinode->clientCanCacheRead == 0) {
eb4b756b
JL		 3129 rc = filemap_fdatawait(inode->i_mapping);
3130 mapping_set_error(inode->i_mapping, rc);
3bc303c2
JL		 3131 invalidate_remote_inode(inode);
3132 }
b6b38f70 3133 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
3bc303c2
JL		 3134 }
3135
85160e03
PS		 3136 rc = cifs_push_locks(cfile);
3137 if (rc)
3138 cERROR(1, "Push locks rc = %d", rc);
3139
3bc303c2
JL		 3140 /*
3141 * releasing stale oplock after recent reconnect of smb session using
3142 * a now incorrect file handle is not a data integrity issue but do
3143 * not bother sending an oplock release if session to server still is
3144 * disconnected since oplock already released by the server
3145 */
cdff08e7 3146 if (!cfile->oplock_break_cancelled) {
03776f45
PS		 3147 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
3148 current->tgid, 0, 0, 0, 0,
3149 LOCKING_ANDX_OPLOCK_RELEASE, false,
12fed00d 3150 cinode->clientCanCacheRead ? 1 : 0);
b6b38f70 3151 cFYI(1, "Oplock release rc = %d", rc);
3bc303c2 3152 }
3bc303c2
JL		 3153}
3154
f5e54d6e 3155const struct address_space_operations cifs_addr_ops = {
1da177e4
LT		 3156 .readpage = cifs_readpage,
3157 .readpages = cifs_readpages,
3158 .writepage = cifs_writepage,
37c0eb46 3159 .writepages = cifs_writepages,
d9414774
NP		 3160 .write_begin = cifs_write_begin,
3161 .write_end = cifs_write_end,
1da177e4 3162 .set_page_dirty = __set_page_dirty_nobuffers,
85f2d6b4
SJ		 3163 .releasepage = cifs_release_page,
3164 .invalidatepage = cifs_invalidate_page,
9ad1506b 3165 .launder_page = cifs_launder_page,
1da177e4 3166};
273d81d6
DK		 3167
3168/*
3169 * cifs_readpages requires the server to support a buffer large enough to
3170 * contain the header plus one complete page of data. Otherwise, we need
3171 * to leave cifs_readpages out of the address space operations.
3172 */
f5e54d6e 3173const struct address_space_operations cifs_addr_ops_smallbuf = {
273d81d6
DK		 3174 .readpage = cifs_readpage,
3175 .writepage = cifs_writepage,
3176 .writepages = cifs_writepages,
d9414774
NP		 3177 .write_begin = cifs_write_begin,
3178 .write_end = cifs_write_end,
273d81d6 3179 .set_page_dirty = __set_page_dirty_nobuffers,
85f2d6b4
SJ		 3180 .releasepage = cifs_release_page,
3181 .invalidatepage = cifs_invalidate_page,
9ad1506b 3182 .launder_page = cifs_launder_page,
273d81d6 3183};
Linux kernel - Deliverables
This page took 2.903013 seconds and 5 git commands to generate.