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