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