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