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