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