4 * vfs operations that deal with files
6 * Copyright (C) International Business Machines Corp., 2002,2010
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 * Jeremy Allison (jra@samba.org)
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.
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.
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
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>
37 #include <asm/div64.h>
41 #include "cifsproto.h"
42 #include "cifs_unicode.h"
43 #include "cifs_debug.h"
44 #include "cifs_fs_sb.h"
46 #include "smbdirect.h"
48 static inline int cifs_convert_flags(unsigned int flags
)
50 if ((flags
& O_ACCMODE
) == O_RDONLY
)
52 else if ((flags
& O_ACCMODE
) == O_WRONLY
)
54 else if ((flags
& O_ACCMODE
) == O_RDWR
) {
55 /* GENERIC_ALL is too much permission to request
56 can cause unnecessary access denied on create */
57 /* return GENERIC_ALL; */
58 return (GENERIC_READ
| GENERIC_WRITE
);
61 return (READ_CONTROL
| FILE_WRITE_ATTRIBUTES
| FILE_READ_ATTRIBUTES
|
62 FILE_WRITE_EA
| FILE_APPEND_DATA
| FILE_WRITE_DATA
|
66 static u32
cifs_posix_convert_flags(unsigned int flags
)
70 if ((flags
& O_ACCMODE
) == O_RDONLY
)
71 posix_flags
= SMB_O_RDONLY
;
72 else if ((flags
& O_ACCMODE
) == O_WRONLY
)
73 posix_flags
= SMB_O_WRONLY
;
74 else if ((flags
& O_ACCMODE
) == O_RDWR
)
75 posix_flags
= SMB_O_RDWR
;
77 if (flags
& O_CREAT
) {
78 posix_flags
|= SMB_O_CREAT
;
80 posix_flags
|= SMB_O_EXCL
;
81 } else if (flags
& O_EXCL
)
82 cifs_dbg(FYI
, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
83 current
->comm
, current
->tgid
);
86 posix_flags
|= SMB_O_TRUNC
;
87 /* be safe and imply O_SYNC for O_DSYNC */
89 posix_flags
|= SMB_O_SYNC
;
90 if (flags
& O_DIRECTORY
)
91 posix_flags
|= SMB_O_DIRECTORY
;
92 if (flags
& O_NOFOLLOW
)
93 posix_flags
|= SMB_O_NOFOLLOW
;
95 posix_flags
|= SMB_O_DIRECT
;
100 static inline int cifs_get_disposition(unsigned int flags
)
102 if ((flags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
104 else if ((flags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
105 return FILE_OVERWRITE_IF
;
106 else if ((flags
& O_CREAT
) == O_CREAT
)
108 else if ((flags
& O_TRUNC
) == O_TRUNC
)
109 return FILE_OVERWRITE
;
114 int cifs_posix_open(char *full_path
, struct inode
**pinode
,
115 struct super_block
*sb
, int mode
, unsigned int f_flags
,
116 __u32
*poplock
, __u16
*pnetfid
, unsigned int xid
)
119 FILE_UNIX_BASIC_INFO
*presp_data
;
120 __u32 posix_flags
= 0;
121 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
122 struct cifs_fattr fattr
;
123 struct tcon_link
*tlink
;
124 struct cifs_tcon
*tcon
;
126 cifs_dbg(FYI
, "posix open %s\n", full_path
);
128 presp_data
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
129 if (presp_data
== NULL
)
132 tlink
= cifs_sb_tlink(cifs_sb
);
138 tcon
= tlink_tcon(tlink
);
139 mode
&= ~current_umask();
141 posix_flags
= cifs_posix_convert_flags(f_flags
);
142 rc
= CIFSPOSIXCreate(xid
, tcon
, posix_flags
, mode
, pnetfid
, presp_data
,
143 poplock
, full_path
, cifs_sb
->local_nls
,
144 cifs_remap(cifs_sb
));
145 cifs_put_tlink(tlink
);
150 if (presp_data
->Type
== cpu_to_le32(-1))
151 goto posix_open_ret
; /* open ok, caller does qpathinfo */
154 goto posix_open_ret
; /* caller does not need info */
156 cifs_unix_basic_to_fattr(&fattr
, presp_data
, cifs_sb
);
158 /* get new inode and set it up */
159 if (*pinode
== NULL
) {
160 cifs_fill_uniqueid(sb
, &fattr
);
161 *pinode
= cifs_iget(sb
, &fattr
);
167 cifs_fattr_to_inode(*pinode
, &fattr
);
176 cifs_nt_open(char *full_path
, struct inode
*inode
, struct cifs_sb_info
*cifs_sb
,
177 struct cifs_tcon
*tcon
, unsigned int f_flags
, __u32
*oplock
,
178 struct cifs_fid
*fid
, unsigned int xid
)
183 int create_options
= CREATE_NOT_DIR
;
185 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
186 struct cifs_open_parms oparms
;
188 if (!server
->ops
->open
)
191 desired_access
= cifs_convert_flags(f_flags
);
193 /*********************************************************************
194 * open flag mapping table:
196 * POSIX Flag CIFS Disposition
197 * ---------- ----------------
198 * O_CREAT FILE_OPEN_IF
199 * O_CREAT | O_EXCL FILE_CREATE
200 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
201 * O_TRUNC FILE_OVERWRITE
202 * none of the above FILE_OPEN
204 * Note that there is not a direct match between disposition
205 * FILE_SUPERSEDE (ie create whether or not file exists although
206 * O_CREAT | O_TRUNC is similar but truncates the existing
207 * file rather than creating a new file as FILE_SUPERSEDE does
208 * (which uses the attributes / metadata passed in on open call)
210 *? O_SYNC is a reasonable match to CIFS writethrough flag
211 *? and the read write flags match reasonably. O_LARGEFILE
212 *? is irrelevant because largefile support is always used
213 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
214 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
215 *********************************************************************/
217 disposition
= cifs_get_disposition(f_flags
);
219 /* BB pass O_SYNC flag through on file attributes .. BB */
221 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
225 if (backup_cred(cifs_sb
))
226 create_options
|= CREATE_OPEN_BACKUP_INTENT
;
228 /* O_SYNC also has bit for O_DSYNC so following check picks up either */
229 if (f_flags
& O_SYNC
)
230 create_options
|= CREATE_WRITE_THROUGH
;
232 if (f_flags
& O_DIRECT
)
233 create_options
|= CREATE_NO_BUFFER
;
236 oparms
.cifs_sb
= cifs_sb
;
237 oparms
.desired_access
= desired_access
;
238 oparms
.create_options
= create_options
;
239 oparms
.disposition
= disposition
;
240 oparms
.path
= full_path
;
242 oparms
.reconnect
= false;
244 rc
= server
->ops
->open(xid
, &oparms
, oplock
, buf
);
250 rc
= cifs_get_inode_info_unix(&inode
, full_path
, inode
->i_sb
,
253 rc
= cifs_get_inode_info(&inode
, full_path
, buf
, inode
->i_sb
,
262 cifs_has_mand_locks(struct cifsInodeInfo
*cinode
)
264 struct cifs_fid_locks
*cur
;
265 bool has_locks
= false;
267 down_read(&cinode
->lock_sem
);
268 list_for_each_entry(cur
, &cinode
->llist
, llist
) {
269 if (!list_empty(&cur
->locks
)) {
274 up_read(&cinode
->lock_sem
);
278 struct cifsFileInfo
*
279 cifs_new_fileinfo(struct cifs_fid
*fid
, struct file
*file
,
280 struct tcon_link
*tlink
, __u32 oplock
)
282 struct dentry
*dentry
= file_dentry(file
);
283 struct inode
*inode
= d_inode(dentry
);
284 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
285 struct cifsFileInfo
*cfile
;
286 struct cifs_fid_locks
*fdlocks
;
287 struct cifs_tcon
*tcon
= tlink_tcon(tlink
);
288 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
290 cfile
= kzalloc(sizeof(struct cifsFileInfo
), GFP_KERNEL
);
294 fdlocks
= kzalloc(sizeof(struct cifs_fid_locks
), GFP_KERNEL
);
300 INIT_LIST_HEAD(&fdlocks
->locks
);
301 fdlocks
->cfile
= cfile
;
302 cfile
->llist
= fdlocks
;
303 down_write(&cinode
->lock_sem
);
304 list_add(&fdlocks
->llist
, &cinode
->llist
);
305 up_write(&cinode
->lock_sem
);
308 cfile
->pid
= current
->tgid
;
309 cfile
->uid
= current_fsuid();
310 cfile
->dentry
= dget(dentry
);
311 cfile
->f_flags
= file
->f_flags
;
312 cfile
->invalidHandle
= false;
313 cfile
->tlink
= cifs_get_tlink(tlink
);
314 INIT_WORK(&cfile
->oplock_break
, cifs_oplock_break
);
315 mutex_init(&cfile
->fh_mutex
);
316 spin_lock_init(&cfile
->file_info_lock
);
318 cifs_sb_active(inode
->i_sb
);
321 * If the server returned a read oplock and we have mandatory brlocks,
322 * set oplock level to None.
324 if (server
->ops
->is_read_op(oplock
) && cifs_has_mand_locks(cinode
)) {
325 cifs_dbg(FYI
, "Reset oplock val from read to None due to mand locks\n");
329 spin_lock(&tcon
->open_file_lock
);
330 if (fid
->pending_open
->oplock
!= CIFS_OPLOCK_NO_CHANGE
&& oplock
)
331 oplock
= fid
->pending_open
->oplock
;
332 list_del(&fid
->pending_open
->olist
);
334 fid
->purge_cache
= false;
335 server
->ops
->set_fid(cfile
, fid
, oplock
);
337 list_add(&cfile
->tlist
, &tcon
->openFileList
);
338 atomic_inc(&tcon
->num_local_opens
);
340 /* if readable file instance put first in list*/
341 if (file
->f_mode
& FMODE_READ
)
342 list_add(&cfile
->flist
, &cinode
->openFileList
);
344 list_add_tail(&cfile
->flist
, &cinode
->openFileList
);
345 spin_unlock(&tcon
->open_file_lock
);
347 if (fid
->purge_cache
)
348 cifs_zap_mapping(inode
);
350 file
->private_data
= cfile
;
354 struct cifsFileInfo
*
355 cifsFileInfo_get(struct cifsFileInfo
*cifs_file
)
357 spin_lock(&cifs_file
->file_info_lock
);
358 cifsFileInfo_get_locked(cifs_file
);
359 spin_unlock(&cifs_file
->file_info_lock
);
364 * Release a reference on the file private data. This may involve closing
365 * the filehandle out on the server. Must be called without holding
366 * tcon->open_file_lock and cifs_file->file_info_lock.
368 void cifsFileInfo_put(struct cifsFileInfo
*cifs_file
)
370 struct inode
*inode
= d_inode(cifs_file
->dentry
);
371 struct cifs_tcon
*tcon
= tlink_tcon(cifs_file
->tlink
);
372 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
373 struct cifsInodeInfo
*cifsi
= CIFS_I(inode
);
374 struct super_block
*sb
= inode
->i_sb
;
375 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
376 struct cifsLockInfo
*li
, *tmp
;
378 struct cifs_pending_open open
;
379 bool oplock_break_cancelled
;
381 spin_lock(&tcon
->open_file_lock
);
383 spin_lock(&cifs_file
->file_info_lock
);
384 if (--cifs_file
->count
> 0) {
385 spin_unlock(&cifs_file
->file_info_lock
);
386 spin_unlock(&tcon
->open_file_lock
);
389 spin_unlock(&cifs_file
->file_info_lock
);
391 if (server
->ops
->get_lease_key
)
392 server
->ops
->get_lease_key(inode
, &fid
);
394 /* store open in pending opens to make sure we don't miss lease break */
395 cifs_add_pending_open_locked(&fid
, cifs_file
->tlink
, &open
);
397 /* remove it from the lists */
398 list_del(&cifs_file
->flist
);
399 list_del(&cifs_file
->tlist
);
400 atomic_dec(&tcon
->num_local_opens
);
402 if (list_empty(&cifsi
->openFileList
)) {
403 cifs_dbg(FYI
, "closing last open instance for inode %p\n",
404 d_inode(cifs_file
->dentry
));
406 * In strict cache mode we need invalidate mapping on the last
407 * close because it may cause a error when we open this file
408 * again and get at least level II oplock.
410 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_STRICT_IO
)
411 set_bit(CIFS_INO_INVALID_MAPPING
, &cifsi
->flags
);
412 cifs_set_oplock_level(cifsi
, 0);
415 spin_unlock(&tcon
->open_file_lock
);
417 oplock_break_cancelled
= cancel_work_sync(&cifs_file
->oplock_break
);
419 if (!tcon
->need_reconnect
&& !cifs_file
->invalidHandle
) {
420 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
424 if (server
->ops
->close
)
425 server
->ops
->close(xid
, tcon
, &cifs_file
->fid
);
429 if (oplock_break_cancelled
)
430 cifs_done_oplock_break(cifsi
);
432 cifs_del_pending_open(&open
);
435 * Delete any outstanding lock records. We'll lose them when the file
438 down_write(&cifsi
->lock_sem
);
439 list_for_each_entry_safe(li
, tmp
, &cifs_file
->llist
->locks
, llist
) {
440 list_del(&li
->llist
);
441 cifs_del_lock_waiters(li
);
444 list_del(&cifs_file
->llist
->llist
);
445 kfree(cifs_file
->llist
);
446 up_write(&cifsi
->lock_sem
);
448 cifs_put_tlink(cifs_file
->tlink
);
449 dput(cifs_file
->dentry
);
450 cifs_sb_deactive(sb
);
454 int cifs_open(struct inode
*inode
, struct file
*file
)
460 struct cifs_sb_info
*cifs_sb
;
461 struct TCP_Server_Info
*server
;
462 struct cifs_tcon
*tcon
;
463 struct tcon_link
*tlink
;
464 struct cifsFileInfo
*cfile
= NULL
;
465 char *full_path
= NULL
;
466 bool posix_open_ok
= false;
468 struct cifs_pending_open open
;
472 cifs_sb
= CIFS_SB(inode
->i_sb
);
473 tlink
= cifs_sb_tlink(cifs_sb
);
476 return PTR_ERR(tlink
);
478 tcon
= tlink_tcon(tlink
);
479 server
= tcon
->ses
->server
;
481 full_path
= build_path_from_dentry(file_dentry(file
));
482 if (full_path
== NULL
) {
487 cifs_dbg(FYI
, "inode = 0x%p file flags are 0x%x for %s\n",
488 inode
, file
->f_flags
, full_path
);
490 if (file
->f_flags
& O_DIRECT
&&
491 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_STRICT_IO
) {
492 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
493 file
->f_op
= &cifs_file_direct_nobrl_ops
;
495 file
->f_op
= &cifs_file_direct_ops
;
503 if (!tcon
->broken_posix_open
&& tcon
->unix_ext
&&
504 cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
505 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
506 /* can not refresh inode info since size could be stale */
507 rc
= cifs_posix_open(full_path
, &inode
, inode
->i_sb
,
508 cifs_sb
->mnt_file_mode
/* ignored */,
509 file
->f_flags
, &oplock
, &fid
.netfid
, xid
);
511 cifs_dbg(FYI
, "posix open succeeded\n");
512 posix_open_ok
= true;
513 } else if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
514 if (tcon
->ses
->serverNOS
)
515 cifs_dbg(VFS
, "server %s of type %s returned unexpected error on SMB posix open, disabling posix open support. Check if server update available.\n",
516 tcon
->ses
->serverName
,
517 tcon
->ses
->serverNOS
);
518 tcon
->broken_posix_open
= true;
519 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
520 (rc
!= -EOPNOTSUPP
)) /* path not found or net err */
523 * Else fallthrough to retry open the old way on network i/o
528 if (server
->ops
->get_lease_key
)
529 server
->ops
->get_lease_key(inode
, &fid
);
531 cifs_add_pending_open(&fid
, tlink
, &open
);
533 if (!posix_open_ok
) {
534 if (server
->ops
->get_lease_key
)
535 server
->ops
->get_lease_key(inode
, &fid
);
537 rc
= cifs_nt_open(full_path
, inode
, cifs_sb
, tcon
,
538 file
->f_flags
, &oplock
, &fid
, xid
);
540 cifs_del_pending_open(&open
);
545 cfile
= cifs_new_fileinfo(&fid
, file
, tlink
, oplock
);
547 if (server
->ops
->close
)
548 server
->ops
->close(xid
, tcon
, &fid
);
549 cifs_del_pending_open(&open
);
554 cifs_fscache_set_inode_cookie(inode
, file
);
556 if ((oplock
& CIFS_CREATE_ACTION
) && !posix_open_ok
&& tcon
->unix_ext
) {
558 * Time to set mode which we can not set earlier due to
559 * problems creating new read-only files.
561 struct cifs_unix_set_info_args args
= {
562 .mode
= inode
->i_mode
,
563 .uid
= INVALID_UID
, /* no change */
564 .gid
= INVALID_GID
, /* no change */
565 .ctime
= NO_CHANGE_64
,
566 .atime
= NO_CHANGE_64
,
567 .mtime
= NO_CHANGE_64
,
570 CIFSSMBUnixSetFileInfo(xid
, tcon
, &args
, fid
.netfid
,
577 cifs_put_tlink(tlink
);
581 static int cifs_push_posix_locks(struct cifsFileInfo
*cfile
);
584 * Try to reacquire byte range locks that were released when session
585 * to server was lost.
588 cifs_relock_file(struct cifsFileInfo
*cfile
)
590 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->dentry
->d_sb
);
591 struct cifsInodeInfo
*cinode
= CIFS_I(d_inode(cfile
->dentry
));
592 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
595 down_read_nested(&cinode
->lock_sem
, SINGLE_DEPTH_NESTING
);
596 if (cinode
->can_cache_brlcks
) {
597 /* can cache locks - no need to relock */
598 up_read(&cinode
->lock_sem
);
602 if (cap_unix(tcon
->ses
) &&
603 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
604 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
605 rc
= cifs_push_posix_locks(cfile
);
607 rc
= tcon
->ses
->server
->ops
->push_mand_locks(cfile
);
609 up_read(&cinode
->lock_sem
);
614 cifs_reopen_file(struct cifsFileInfo
*cfile
, bool can_flush
)
619 struct cifs_sb_info
*cifs_sb
;
620 struct cifs_tcon
*tcon
;
621 struct TCP_Server_Info
*server
;
622 struct cifsInodeInfo
*cinode
;
624 char *full_path
= NULL
;
626 int disposition
= FILE_OPEN
;
627 int create_options
= CREATE_NOT_DIR
;
628 struct cifs_open_parms oparms
;
631 mutex_lock(&cfile
->fh_mutex
);
632 if (!cfile
->invalidHandle
) {
633 mutex_unlock(&cfile
->fh_mutex
);
639 inode
= d_inode(cfile
->dentry
);
640 cifs_sb
= CIFS_SB(inode
->i_sb
);
641 tcon
= tlink_tcon(cfile
->tlink
);
642 server
= tcon
->ses
->server
;
645 * Can not grab rename sem here because various ops, including those
646 * that already have the rename sem can end up causing writepage to get
647 * called and if the server was down that means we end up here, and we
648 * can never tell if the caller already has the rename_sem.
650 full_path
= build_path_from_dentry(cfile
->dentry
);
651 if (full_path
== NULL
) {
653 mutex_unlock(&cfile
->fh_mutex
);
658 cifs_dbg(FYI
, "inode = 0x%p file flags 0x%x for %s\n",
659 inode
, cfile
->f_flags
, full_path
);
661 if (tcon
->ses
->server
->oplocks
)
666 if (tcon
->unix_ext
&& cap_unix(tcon
->ses
) &&
667 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
668 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
670 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
671 * original open. Must mask them off for a reopen.
673 unsigned int oflags
= cfile
->f_flags
&
674 ~(O_CREAT
| O_EXCL
| O_TRUNC
);
676 rc
= cifs_posix_open(full_path
, NULL
, inode
->i_sb
,
677 cifs_sb
->mnt_file_mode
/* ignored */,
678 oflags
, &oplock
, &cfile
->fid
.netfid
, xid
);
680 cifs_dbg(FYI
, "posix reopen succeeded\n");
681 oparms
.reconnect
= true;
685 * fallthrough to retry open the old way on errors, especially
686 * in the reconnect path it is important to retry hard
690 desired_access
= cifs_convert_flags(cfile
->f_flags
);
692 if (backup_cred(cifs_sb
))
693 create_options
|= CREATE_OPEN_BACKUP_INTENT
;
695 if (server
->ops
->get_lease_key
)
696 server
->ops
->get_lease_key(inode
, &cfile
->fid
);
699 oparms
.cifs_sb
= cifs_sb
;
700 oparms
.desired_access
= desired_access
;
701 oparms
.create_options
= create_options
;
702 oparms
.disposition
= disposition
;
703 oparms
.path
= full_path
;
704 oparms
.fid
= &cfile
->fid
;
705 oparms
.reconnect
= true;
708 * Can not refresh inode by passing in file_info buf to be returned by
709 * ops->open and then calling get_inode_info with returned buf since
710 * file might have write behind data that needs to be flushed and server
711 * version of file size can be stale. If we knew for sure that inode was
712 * not dirty locally we could do this.
714 rc
= server
->ops
->open(xid
, &oparms
, &oplock
, NULL
);
715 if (rc
== -ENOENT
&& oparms
.reconnect
== false) {
716 /* durable handle timeout is expired - open the file again */
717 rc
= server
->ops
->open(xid
, &oparms
, &oplock
, NULL
);
718 /* indicate that we need to relock the file */
719 oparms
.reconnect
= true;
723 mutex_unlock(&cfile
->fh_mutex
);
724 cifs_dbg(FYI
, "cifs_reopen returned 0x%x\n", rc
);
725 cifs_dbg(FYI
, "oplock: %d\n", oplock
);
726 goto reopen_error_exit
;
730 cfile
->invalidHandle
= false;
731 mutex_unlock(&cfile
->fh_mutex
);
732 cinode
= CIFS_I(inode
);
735 rc
= filemap_write_and_wait(inode
->i_mapping
);
736 if (!is_interrupt_error(rc
))
737 mapping_set_error(inode
->i_mapping
, rc
);
740 rc
= cifs_get_inode_info_unix(&inode
, full_path
,
743 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
,
744 inode
->i_sb
, xid
, NULL
);
747 * Else we are writing out data to server already and could deadlock if
748 * we tried to flush data, and since we do not know if we have data that
749 * would invalidate the current end of file on the server we can not go
750 * to the server to get the new inode info.
754 * If the server returned a read oplock and we have mandatory brlocks,
755 * set oplock level to None.
757 if (server
->ops
->is_read_op(oplock
) && cifs_has_mand_locks(cinode
)) {
758 cifs_dbg(FYI
, "Reset oplock val from read to None due to mand locks\n");
762 server
->ops
->set_fid(cfile
, &cfile
->fid
, oplock
);
763 if (oparms
.reconnect
)
764 cifs_relock_file(cfile
);
772 int cifs_close(struct inode
*inode
, struct file
*file
)
774 if (file
->private_data
!= NULL
) {
775 cifsFileInfo_put(file
->private_data
);
776 file
->private_data
= NULL
;
779 /* return code from the ->release op is always ignored */
784 cifs_reopen_persistent_handles(struct cifs_tcon
*tcon
)
786 struct cifsFileInfo
*open_file
;
787 struct list_head
*tmp
;
788 struct list_head
*tmp1
;
789 struct list_head tmp_list
;
791 if (!tcon
->use_persistent
|| !tcon
->need_reopen_files
)
794 tcon
->need_reopen_files
= false;
796 cifs_dbg(FYI
, "Reopen persistent handles");
797 INIT_LIST_HEAD(&tmp_list
);
799 /* list all files open on tree connection, reopen resilient handles */
800 spin_lock(&tcon
->open_file_lock
);
801 list_for_each(tmp
, &tcon
->openFileList
) {
802 open_file
= list_entry(tmp
, struct cifsFileInfo
, tlist
);
803 if (!open_file
->invalidHandle
)
805 cifsFileInfo_get(open_file
);
806 list_add_tail(&open_file
->rlist
, &tmp_list
);
808 spin_unlock(&tcon
->open_file_lock
);
810 list_for_each_safe(tmp
, tmp1
, &tmp_list
) {
811 open_file
= list_entry(tmp
, struct cifsFileInfo
, rlist
);
812 if (cifs_reopen_file(open_file
, false /* do not flush */))
813 tcon
->need_reopen_files
= true;
814 list_del_init(&open_file
->rlist
);
815 cifsFileInfo_put(open_file
);
819 int cifs_closedir(struct inode
*inode
, struct file
*file
)
823 struct cifsFileInfo
*cfile
= file
->private_data
;
824 struct cifs_tcon
*tcon
;
825 struct TCP_Server_Info
*server
;
828 cifs_dbg(FYI
, "Closedir inode = 0x%p\n", inode
);
834 tcon
= tlink_tcon(cfile
->tlink
);
835 server
= tcon
->ses
->server
;
837 cifs_dbg(FYI
, "Freeing private data in close dir\n");
838 spin_lock(&cfile
->file_info_lock
);
839 if (server
->ops
->dir_needs_close(cfile
)) {
840 cfile
->invalidHandle
= true;
841 spin_unlock(&cfile
->file_info_lock
);
842 if (server
->ops
->close_dir
)
843 rc
= server
->ops
->close_dir(xid
, tcon
, &cfile
->fid
);
846 cifs_dbg(FYI
, "Closing uncompleted readdir with rc %d\n", rc
);
847 /* not much we can do if it fails anyway, ignore rc */
850 spin_unlock(&cfile
->file_info_lock
);
852 buf
= cfile
->srch_inf
.ntwrk_buf_start
;
854 cifs_dbg(FYI
, "closedir free smb buf in srch struct\n");
855 cfile
->srch_inf
.ntwrk_buf_start
= NULL
;
856 if (cfile
->srch_inf
.smallBuf
)
857 cifs_small_buf_release(buf
);
859 cifs_buf_release(buf
);
862 cifs_put_tlink(cfile
->tlink
);
863 kfree(file
->private_data
);
864 file
->private_data
= NULL
;
865 /* BB can we lock the filestruct while this is going on? */
870 static struct cifsLockInfo
*
871 cifs_lock_init(__u64 offset
, __u64 length
, __u8 type
, __u16 flags
)
873 struct cifsLockInfo
*lock
=
874 kmalloc(sizeof(struct cifsLockInfo
), GFP_KERNEL
);
877 lock
->offset
= offset
;
878 lock
->length
= length
;
880 lock
->pid
= current
->tgid
;
882 INIT_LIST_HEAD(&lock
->blist
);
883 init_waitqueue_head(&lock
->block_q
);
888 cifs_del_lock_waiters(struct cifsLockInfo
*lock
)
890 struct cifsLockInfo
*li
, *tmp
;
891 list_for_each_entry_safe(li
, tmp
, &lock
->blist
, blist
) {
892 list_del_init(&li
->blist
);
893 wake_up(&li
->block_q
);
897 #define CIFS_LOCK_OP 0
898 #define CIFS_READ_OP 1
899 #define CIFS_WRITE_OP 2
901 /* @rw_check : 0 - no op, 1 - read, 2 - write */
903 cifs_find_fid_lock_conflict(struct cifs_fid_locks
*fdlocks
, __u64 offset
,
904 __u64 length
, __u8 type
, __u16 flags
,
905 struct cifsFileInfo
*cfile
,
906 struct cifsLockInfo
**conf_lock
, int rw_check
)
908 struct cifsLockInfo
*li
;
909 struct cifsFileInfo
*cur_cfile
= fdlocks
->cfile
;
910 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
912 list_for_each_entry(li
, &fdlocks
->locks
, llist
) {
913 if (offset
+ length
<= li
->offset
||
914 offset
>= li
->offset
+ li
->length
)
916 if (rw_check
!= CIFS_LOCK_OP
&& current
->tgid
== li
->pid
&&
917 server
->ops
->compare_fids(cfile
, cur_cfile
)) {
918 /* shared lock prevents write op through the same fid */
919 if (!(li
->type
& server
->vals
->shared_lock_type
) ||
920 rw_check
!= CIFS_WRITE_OP
)
923 if ((type
& server
->vals
->shared_lock_type
) &&
924 ((server
->ops
->compare_fids(cfile
, cur_cfile
) &&
925 current
->tgid
== li
->pid
) || type
== li
->type
))
927 if (rw_check
== CIFS_LOCK_OP
&&
928 (flags
& FL_OFDLCK
) && (li
->flags
& FL_OFDLCK
) &&
929 server
->ops
->compare_fids(cfile
, cur_cfile
))
939 cifs_find_lock_conflict(struct cifsFileInfo
*cfile
, __u64 offset
, __u64 length
,
940 __u8 type
, __u16 flags
,
941 struct cifsLockInfo
**conf_lock
, int rw_check
)
944 struct cifs_fid_locks
*cur
;
945 struct cifsInodeInfo
*cinode
= CIFS_I(d_inode(cfile
->dentry
));
947 list_for_each_entry(cur
, &cinode
->llist
, llist
) {
948 rc
= cifs_find_fid_lock_conflict(cur
, offset
, length
, type
,
949 flags
, cfile
, conf_lock
,
959 * Check if there is another lock that prevents us to set the lock (mandatory
960 * style). If such a lock exists, update the flock structure with its
961 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
962 * or leave it the same if we can't. Returns 0 if we don't need to request to
963 * the server or 1 otherwise.
966 cifs_lock_test(struct cifsFileInfo
*cfile
, __u64 offset
, __u64 length
,
967 __u8 type
, struct file_lock
*flock
)
970 struct cifsLockInfo
*conf_lock
;
971 struct cifsInodeInfo
*cinode
= CIFS_I(d_inode(cfile
->dentry
));
972 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
975 down_read(&cinode
->lock_sem
);
977 exist
= cifs_find_lock_conflict(cfile
, offset
, length
, type
,
978 flock
->fl_flags
, &conf_lock
,
981 flock
->fl_start
= conf_lock
->offset
;
982 flock
->fl_end
= conf_lock
->offset
+ conf_lock
->length
- 1;
983 flock
->fl_pid
= conf_lock
->pid
;
984 if (conf_lock
->type
& server
->vals
->shared_lock_type
)
985 flock
->fl_type
= F_RDLCK
;
987 flock
->fl_type
= F_WRLCK
;
988 } else if (!cinode
->can_cache_brlcks
)
991 flock
->fl_type
= F_UNLCK
;
993 up_read(&cinode
->lock_sem
);
998 cifs_lock_add(struct cifsFileInfo
*cfile
, struct cifsLockInfo
*lock
)
1000 struct cifsInodeInfo
*cinode
= CIFS_I(d_inode(cfile
->dentry
));
1001 down_write(&cinode
->lock_sem
);
1002 list_add_tail(&lock
->llist
, &cfile
->llist
->locks
);
1003 up_write(&cinode
->lock_sem
);
1007 * Set the byte-range lock (mandatory style). Returns:
1008 * 1) 0, if we set the lock and don't need to request to the server;
1009 * 2) 1, if no locks prevent us but we need to request to the server;
1010 * 3) -EACCES, if there is a lock that prevents us and wait is false.
1013 cifs_lock_add_if(struct cifsFileInfo
*cfile
, struct cifsLockInfo
*lock
,
1016 struct cifsLockInfo
*conf_lock
;
1017 struct cifsInodeInfo
*cinode
= CIFS_I(d_inode(cfile
->dentry
));
1023 down_write(&cinode
->lock_sem
);
1025 exist
= cifs_find_lock_conflict(cfile
, lock
->offset
, lock
->length
,
1026 lock
->type
, lock
->flags
, &conf_lock
,
1028 if (!exist
&& cinode
->can_cache_brlcks
) {
1029 list_add_tail(&lock
->llist
, &cfile
->llist
->locks
);
1030 up_write(&cinode
->lock_sem
);
1039 list_add_tail(&lock
->blist
, &conf_lock
->blist
);
1040 up_write(&cinode
->lock_sem
);
1041 rc
= wait_event_interruptible(lock
->block_q
,
1042 (lock
->blist
.prev
== &lock
->blist
) &&
1043 (lock
->blist
.next
== &lock
->blist
));
1046 down_write(&cinode
->lock_sem
);
1047 list_del_init(&lock
->blist
);
1050 up_write(&cinode
->lock_sem
);
1055 * Check if there is another lock that prevents us to set the lock (posix
1056 * style). If such a lock exists, update the flock structure with its
1057 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1058 * or leave it the same if we can't. Returns 0 if we don't need to request to
1059 * the server or 1 otherwise.
1062 cifs_posix_lock_test(struct file
*file
, struct file_lock
*flock
)
1065 struct cifsInodeInfo
*cinode
= CIFS_I(file_inode(file
));
1066 unsigned char saved_type
= flock
->fl_type
;
1068 if ((flock
->fl_flags
& FL_POSIX
) == 0)
1071 down_read(&cinode
->lock_sem
);
1072 posix_test_lock(file
, flock
);
1074 if (flock
->fl_type
== F_UNLCK
&& !cinode
->can_cache_brlcks
) {
1075 flock
->fl_type
= saved_type
;
1079 up_read(&cinode
->lock_sem
);
1084 * Set the byte-range lock (posix style). Returns:
1085 * 1) 0, if we set the lock and don't need to request to the server;
1086 * 2) 1, if we need to request to the server;
1087 * 3) <0, if the error occurs while setting the lock.
1090 cifs_posix_lock_set(struct file
*file
, struct file_lock
*flock
)
1092 struct cifsInodeInfo
*cinode
= CIFS_I(file_inode(file
));
1095 if ((flock
->fl_flags
& FL_POSIX
) == 0)
1099 down_write(&cinode
->lock_sem
);
1100 if (!cinode
->can_cache_brlcks
) {
1101 up_write(&cinode
->lock_sem
);
1105 rc
= posix_lock_file(file
, flock
, NULL
);
1106 up_write(&cinode
->lock_sem
);
1107 if (rc
== FILE_LOCK_DEFERRED
) {
1108 rc
= wait_event_interruptible(flock
->fl_wait
, !flock
->fl_blocker
);
1111 locks_delete_block(flock
);
1117 cifs_push_mandatory_locks(struct cifsFileInfo
*cfile
)
1120 int rc
= 0, stored_rc
;
1121 struct cifsLockInfo
*li
, *tmp
;
1122 struct cifs_tcon
*tcon
;
1123 unsigned int num
, max_num
, max_buf
;
1124 LOCKING_ANDX_RANGE
*buf
, *cur
;
1125 static const int types
[] = {
1126 LOCKING_ANDX_LARGE_FILES
,
1127 LOCKING_ANDX_SHARED_LOCK
| LOCKING_ANDX_LARGE_FILES
1132 tcon
= tlink_tcon(cfile
->tlink
);
1135 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1136 * and check it before using.
1138 max_buf
= tcon
->ses
->server
->maxBuf
;
1139 if (max_buf
< (sizeof(struct smb_hdr
) + sizeof(LOCKING_ANDX_RANGE
))) {
1144 BUILD_BUG_ON(sizeof(struct smb_hdr
) + sizeof(LOCKING_ANDX_RANGE
) >
1146 max_buf
= min_t(unsigned int, max_buf
- sizeof(struct smb_hdr
),
1148 max_num
= (max_buf
- sizeof(struct smb_hdr
)) /
1149 sizeof(LOCKING_ANDX_RANGE
);
1150 buf
= kcalloc(max_num
, sizeof(LOCKING_ANDX_RANGE
), GFP_KERNEL
);
1156 for (i
= 0; i
< 2; i
++) {
1159 list_for_each_entry_safe(li
, tmp
, &cfile
->llist
->locks
, llist
) {
1160 if (li
->type
!= types
[i
])
1162 cur
->Pid
= cpu_to_le16(li
->pid
);
1163 cur
->LengthLow
= cpu_to_le32((u32
)li
->length
);
1164 cur
->LengthHigh
= cpu_to_le32((u32
)(li
->length
>>32));
1165 cur
->OffsetLow
= cpu_to_le32((u32
)li
->offset
);
1166 cur
->OffsetHigh
= cpu_to_le32((u32
)(li
->offset
>>32));
1167 if (++num
== max_num
) {
1168 stored_rc
= cifs_lockv(xid
, tcon
,
1170 (__u8
)li
->type
, 0, num
,
1181 stored_rc
= cifs_lockv(xid
, tcon
, cfile
->fid
.netfid
,
1182 (__u8
)types
[i
], 0, num
, buf
);
1194 hash_lockowner(fl_owner_t owner
)
1196 return cifs_lock_secret
^ hash32_ptr((const void *)owner
);
1199 struct lock_to_push
{
1200 struct list_head llist
;
1209 cifs_push_posix_locks(struct cifsFileInfo
*cfile
)
1211 struct inode
*inode
= d_inode(cfile
->dentry
);
1212 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1213 struct file_lock
*flock
;
1214 struct file_lock_context
*flctx
= inode
->i_flctx
;
1215 unsigned int count
= 0, i
;
1216 int rc
= 0, xid
, type
;
1217 struct list_head locks_to_send
, *el
;
1218 struct lock_to_push
*lck
, *tmp
;
1226 spin_lock(&flctx
->flc_lock
);
1227 list_for_each(el
, &flctx
->flc_posix
) {
1230 spin_unlock(&flctx
->flc_lock
);
1232 INIT_LIST_HEAD(&locks_to_send
);
1235 * Allocating count locks is enough because no FL_POSIX locks can be
1236 * added to the list while we are holding cinode->lock_sem that
1237 * protects locking operations of this inode.
1239 for (i
= 0; i
< count
; i
++) {
1240 lck
= kmalloc(sizeof(struct lock_to_push
), GFP_KERNEL
);
1245 list_add_tail(&lck
->llist
, &locks_to_send
);
1248 el
= locks_to_send
.next
;
1249 spin_lock(&flctx
->flc_lock
);
1250 list_for_each_entry(flock
, &flctx
->flc_posix
, fl_list
) {
1251 if (el
== &locks_to_send
) {
1253 * The list ended. We don't have enough allocated
1254 * structures - something is really wrong.
1256 cifs_dbg(VFS
, "Can't push all brlocks!\n");
1259 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1260 if (flock
->fl_type
== F_RDLCK
|| flock
->fl_type
== F_SHLCK
)
1264 lck
= list_entry(el
, struct lock_to_push
, llist
);
1265 lck
->pid
= hash_lockowner(flock
->fl_owner
);
1266 lck
->netfid
= cfile
->fid
.netfid
;
1267 lck
->length
= length
;
1269 lck
->offset
= flock
->fl_start
;
1271 spin_unlock(&flctx
->flc_lock
);
1273 list_for_each_entry_safe(lck
, tmp
, &locks_to_send
, llist
) {
1276 stored_rc
= CIFSSMBPosixLock(xid
, tcon
, lck
->netfid
, lck
->pid
,
1277 lck
->offset
, lck
->length
, NULL
,
1281 list_del(&lck
->llist
);
1289 list_for_each_entry_safe(lck
, tmp
, &locks_to_send
, llist
) {
1290 list_del(&lck
->llist
);
1297 cifs_push_locks(struct cifsFileInfo
*cfile
)
1299 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->dentry
->d_sb
);
1300 struct cifsInodeInfo
*cinode
= CIFS_I(d_inode(cfile
->dentry
));
1301 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1304 /* we are going to update can_cache_brlcks here - need a write access */
1305 down_write(&cinode
->lock_sem
);
1306 if (!cinode
->can_cache_brlcks
) {
1307 up_write(&cinode
->lock_sem
);
1311 if (cap_unix(tcon
->ses
) &&
1312 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
1313 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
1314 rc
= cifs_push_posix_locks(cfile
);
1316 rc
= tcon
->ses
->server
->ops
->push_mand_locks(cfile
);
1318 cinode
->can_cache_brlcks
= false;
1319 up_write(&cinode
->lock_sem
);
1324 cifs_read_flock(struct file_lock
*flock
, __u32
*type
, int *lock
, int *unlock
,
1325 bool *wait_flag
, struct TCP_Server_Info
*server
)
1327 if (flock
->fl_flags
& FL_POSIX
)
1328 cifs_dbg(FYI
, "Posix\n");
1329 if (flock
->fl_flags
& FL_FLOCK
)
1330 cifs_dbg(FYI
, "Flock\n");
1331 if (flock
->fl_flags
& FL_SLEEP
) {
1332 cifs_dbg(FYI
, "Blocking lock\n");
1335 if (flock
->fl_flags
& FL_ACCESS
)
1336 cifs_dbg(FYI
, "Process suspended by mandatory locking - not implemented yet\n");
1337 if (flock
->fl_flags
& FL_LEASE
)
1338 cifs_dbg(FYI
, "Lease on file - not implemented yet\n");
1339 if (flock
->fl_flags
&
1340 (~(FL_POSIX
| FL_FLOCK
| FL_SLEEP
|
1341 FL_ACCESS
| FL_LEASE
| FL_CLOSE
| FL_OFDLCK
)))
1342 cifs_dbg(FYI
, "Unknown lock flags 0x%x\n", flock
->fl_flags
);
1344 *type
= server
->vals
->large_lock_type
;
1345 if (flock
->fl_type
== F_WRLCK
) {
1346 cifs_dbg(FYI
, "F_WRLCK\n");
1347 *type
|= server
->vals
->exclusive_lock_type
;
1349 } else if (flock
->fl_type
== F_UNLCK
) {
1350 cifs_dbg(FYI
, "F_UNLCK\n");
1351 *type
|= server
->vals
->unlock_lock_type
;
1353 /* Check if unlock includes more than one lock range */
1354 } else if (flock
->fl_type
== F_RDLCK
) {
1355 cifs_dbg(FYI
, "F_RDLCK\n");
1356 *type
|= server
->vals
->shared_lock_type
;
1358 } else if (flock
->fl_type
== F_EXLCK
) {
1359 cifs_dbg(FYI
, "F_EXLCK\n");
1360 *type
|= server
->vals
->exclusive_lock_type
;
1362 } else if (flock
->fl_type
== F_SHLCK
) {
1363 cifs_dbg(FYI
, "F_SHLCK\n");
1364 *type
|= server
->vals
->shared_lock_type
;
1367 cifs_dbg(FYI
, "Unknown type of lock\n");
1371 cifs_getlk(struct file
*file
, struct file_lock
*flock
, __u32 type
,
1372 bool wait_flag
, bool posix_lck
, unsigned int xid
)
1375 __u64 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1376 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)file
->private_data
;
1377 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1378 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1379 __u16 netfid
= cfile
->fid
.netfid
;
1382 int posix_lock_type
;
1384 rc
= cifs_posix_lock_test(file
, flock
);
1388 if (type
& server
->vals
->shared_lock_type
)
1389 posix_lock_type
= CIFS_RDLCK
;
1391 posix_lock_type
= CIFS_WRLCK
;
1392 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
,
1393 hash_lockowner(flock
->fl_owner
),
1394 flock
->fl_start
, length
, flock
,
1395 posix_lock_type
, wait_flag
);
1399 rc
= cifs_lock_test(cfile
, flock
->fl_start
, length
, type
, flock
);
1403 /* BB we could chain these into one lock request BB */
1404 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
, type
,
1407 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
,
1409 flock
->fl_type
= F_UNLCK
;
1411 cifs_dbg(VFS
, "Error unlocking previously locked range %d during test of lock\n",
1416 if (type
& server
->vals
->shared_lock_type
) {
1417 flock
->fl_type
= F_WRLCK
;
1421 type
&= ~server
->vals
->exclusive_lock_type
;
1423 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
,
1424 type
| server
->vals
->shared_lock_type
,
1427 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
,
1428 type
| server
->vals
->shared_lock_type
, 0, 1, false);
1429 flock
->fl_type
= F_RDLCK
;
1431 cifs_dbg(VFS
, "Error unlocking previously locked range %d during test of lock\n",
1434 flock
->fl_type
= F_WRLCK
;
1440 cifs_move_llist(struct list_head
*source
, struct list_head
*dest
)
1442 struct list_head
*li
, *tmp
;
1443 list_for_each_safe(li
, tmp
, source
)
1444 list_move(li
, dest
);
1448 cifs_free_llist(struct list_head
*llist
)
1450 struct cifsLockInfo
*li
, *tmp
;
1451 list_for_each_entry_safe(li
, tmp
, llist
, llist
) {
1452 cifs_del_lock_waiters(li
);
1453 list_del(&li
->llist
);
1459 cifs_unlock_range(struct cifsFileInfo
*cfile
, struct file_lock
*flock
,
1462 int rc
= 0, stored_rc
;
1463 static const int types
[] = {
1464 LOCKING_ANDX_LARGE_FILES
,
1465 LOCKING_ANDX_SHARED_LOCK
| LOCKING_ANDX_LARGE_FILES
1468 unsigned int max_num
, num
, max_buf
;
1469 LOCKING_ANDX_RANGE
*buf
, *cur
;
1470 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1471 struct cifsInodeInfo
*cinode
= CIFS_I(d_inode(cfile
->dentry
));
1472 struct cifsLockInfo
*li
, *tmp
;
1473 __u64 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1474 struct list_head tmp_llist
;
1476 INIT_LIST_HEAD(&tmp_llist
);
1479 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1480 * and check it before using.
1482 max_buf
= tcon
->ses
->server
->maxBuf
;
1483 if (max_buf
< (sizeof(struct smb_hdr
) + sizeof(LOCKING_ANDX_RANGE
)))
1486 BUILD_BUG_ON(sizeof(struct smb_hdr
) + sizeof(LOCKING_ANDX_RANGE
) >
1488 max_buf
= min_t(unsigned int, max_buf
- sizeof(struct smb_hdr
),
1490 max_num
= (max_buf
- sizeof(struct smb_hdr
)) /
1491 sizeof(LOCKING_ANDX_RANGE
);
1492 buf
= kcalloc(max_num
, sizeof(LOCKING_ANDX_RANGE
), GFP_KERNEL
);
1496 down_write(&cinode
->lock_sem
);
1497 for (i
= 0; i
< 2; i
++) {
1500 list_for_each_entry_safe(li
, tmp
, &cfile
->llist
->locks
, llist
) {
1501 if (flock
->fl_start
> li
->offset
||
1502 (flock
->fl_start
+ length
) <
1503 (li
->offset
+ li
->length
))
1505 if (current
->tgid
!= li
->pid
)
1507 if (types
[i
] != li
->type
)
1509 if (cinode
->can_cache_brlcks
) {
1511 * We can cache brlock requests - simply remove
1512 * a lock from the file's list.
1514 list_del(&li
->llist
);
1515 cifs_del_lock_waiters(li
);
1519 cur
->Pid
= cpu_to_le16(li
->pid
);
1520 cur
->LengthLow
= cpu_to_le32((u32
)li
->length
);
1521 cur
->LengthHigh
= cpu_to_le32((u32
)(li
->length
>>32));
1522 cur
->OffsetLow
= cpu_to_le32((u32
)li
->offset
);
1523 cur
->OffsetHigh
= cpu_to_le32((u32
)(li
->offset
>>32));
1525 * We need to save a lock here to let us add it again to
1526 * the file's list if the unlock range request fails on
1529 list_move(&li
->llist
, &tmp_llist
);
1530 if (++num
== max_num
) {
1531 stored_rc
= cifs_lockv(xid
, tcon
,
1533 li
->type
, num
, 0, buf
);
1536 * We failed on the unlock range
1537 * request - add all locks from the tmp
1538 * list to the head of the file's list.
1540 cifs_move_llist(&tmp_llist
,
1541 &cfile
->llist
->locks
);
1545 * The unlock range request succeed -
1546 * free the tmp list.
1548 cifs_free_llist(&tmp_llist
);
1555 stored_rc
= cifs_lockv(xid
, tcon
, cfile
->fid
.netfid
,
1556 types
[i
], num
, 0, buf
);
1558 cifs_move_llist(&tmp_llist
,
1559 &cfile
->llist
->locks
);
1562 cifs_free_llist(&tmp_llist
);
1566 up_write(&cinode
->lock_sem
);
1572 cifs_setlk(struct file
*file
, struct file_lock
*flock
, __u32 type
,
1573 bool wait_flag
, bool posix_lck
, int lock
, int unlock
,
1577 __u64 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1578 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)file
->private_data
;
1579 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1580 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1581 struct inode
*inode
= d_inode(cfile
->dentry
);
1584 int posix_lock_type
;
1586 rc
= cifs_posix_lock_set(file
, flock
);
1590 if (type
& server
->vals
->shared_lock_type
)
1591 posix_lock_type
= CIFS_RDLCK
;
1593 posix_lock_type
= CIFS_WRLCK
;
1596 posix_lock_type
= CIFS_UNLCK
;
1598 rc
= CIFSSMBPosixLock(xid
, tcon
, cfile
->fid
.netfid
,
1599 hash_lockowner(flock
->fl_owner
),
1600 flock
->fl_start
, length
,
1601 NULL
, posix_lock_type
, wait_flag
);
1606 struct cifsLockInfo
*lock
;
1608 lock
= cifs_lock_init(flock
->fl_start
, length
, type
,
1613 rc
= cifs_lock_add_if(cfile
, lock
, wait_flag
);
1622 * Windows 7 server can delay breaking lease from read to None
1623 * if we set a byte-range lock on a file - break it explicitly
1624 * before sending the lock to the server to be sure the next
1625 * read won't conflict with non-overlapted locks due to
1628 if (!CIFS_CACHE_WRITE(CIFS_I(inode
)) &&
1629 CIFS_CACHE_READ(CIFS_I(inode
))) {
1630 cifs_zap_mapping(inode
);
1631 cifs_dbg(FYI
, "Set no oplock for inode=%p due to mand locks\n",
1633 CIFS_I(inode
)->oplock
= 0;
1636 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
,
1637 type
, 1, 0, wait_flag
);
1643 cifs_lock_add(cfile
, lock
);
1645 rc
= server
->ops
->mand_unlock_range(cfile
, flock
, xid
);
1648 if (flock
->fl_flags
& FL_POSIX
) {
1650 * If this is a request to remove all locks because we
1651 * are closing the file, it doesn't matter if the
1652 * unlocking failed as both cifs.ko and the SMB server
1653 * remove the lock on file close
1656 cifs_dbg(VFS
, "%s failed rc=%d\n", __func__
, rc
);
1657 if (!(flock
->fl_flags
& FL_CLOSE
))
1660 rc
= locks_lock_file_wait(file
, flock
);
1665 int cifs_lock(struct file
*file
, int cmd
, struct file_lock
*flock
)
1668 int lock
= 0, unlock
= 0;
1669 bool wait_flag
= false;
1670 bool posix_lck
= false;
1671 struct cifs_sb_info
*cifs_sb
;
1672 struct cifs_tcon
*tcon
;
1673 struct cifsInodeInfo
*cinode
;
1674 struct cifsFileInfo
*cfile
;
1681 cifs_dbg(FYI
, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1682 cmd
, flock
->fl_flags
, flock
->fl_type
,
1683 flock
->fl_start
, flock
->fl_end
);
1685 cfile
= (struct cifsFileInfo
*)file
->private_data
;
1686 tcon
= tlink_tcon(cfile
->tlink
);
1688 cifs_read_flock(flock
, &type
, &lock
, &unlock
, &wait_flag
,
1690 cifs_sb
= CIFS_FILE_SB(file
);
1691 netfid
= cfile
->fid
.netfid
;
1692 cinode
= CIFS_I(file_inode(file
));
1694 if (cap_unix(tcon
->ses
) &&
1695 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
1696 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
1699 * BB add code here to normalize offset and length to account for
1700 * negative length which we can not accept over the wire.
1702 if (IS_GETLK(cmd
)) {
1703 rc
= cifs_getlk(file
, flock
, type
, wait_flag
, posix_lck
, xid
);
1708 if (!lock
&& !unlock
) {
1710 * if no lock or unlock then nothing to do since we do not
1717 rc
= cifs_setlk(file
, flock
, type
, wait_flag
, posix_lck
, lock
, unlock
,
1724 * update the file size (if needed) after a write. Should be called with
1725 * the inode->i_lock held
1728 cifs_update_eof(struct cifsInodeInfo
*cifsi
, loff_t offset
,
1729 unsigned int bytes_written
)
1731 loff_t end_of_write
= offset
+ bytes_written
;
1733 if (end_of_write
> cifsi
->server_eof
)
1734 cifsi
->server_eof
= end_of_write
;
1738 cifs_write(struct cifsFileInfo
*open_file
, __u32 pid
, const char *write_data
,
1739 size_t write_size
, loff_t
*offset
)
1742 unsigned int bytes_written
= 0;
1743 unsigned int total_written
;
1744 struct cifs_sb_info
*cifs_sb
;
1745 struct cifs_tcon
*tcon
;
1746 struct TCP_Server_Info
*server
;
1748 struct dentry
*dentry
= open_file
->dentry
;
1749 struct cifsInodeInfo
*cifsi
= CIFS_I(d_inode(dentry
));
1750 struct cifs_io_parms io_parms
;
1752 cifs_sb
= CIFS_SB(dentry
->d_sb
);
1754 cifs_dbg(FYI
, "write %zd bytes to offset %lld of %pd\n",
1755 write_size
, *offset
, dentry
);
1757 tcon
= tlink_tcon(open_file
->tlink
);
1758 server
= tcon
->ses
->server
;
1760 if (!server
->ops
->sync_write
)
1765 for (total_written
= 0; write_size
> total_written
;
1766 total_written
+= bytes_written
) {
1768 while (rc
== -EAGAIN
) {
1772 if (open_file
->invalidHandle
) {
1773 /* we could deadlock if we called
1774 filemap_fdatawait from here so tell
1775 reopen_file not to flush data to
1777 rc
= cifs_reopen_file(open_file
, false);
1782 len
= min(server
->ops
->wp_retry_size(d_inode(dentry
)),
1783 (unsigned int)write_size
- total_written
);
1784 /* iov[0] is reserved for smb header */
1785 iov
[1].iov_base
= (char *)write_data
+ total_written
;
1786 iov
[1].iov_len
= len
;
1788 io_parms
.tcon
= tcon
;
1789 io_parms
.offset
= *offset
;
1790 io_parms
.length
= len
;
1791 rc
= server
->ops
->sync_write(xid
, &open_file
->fid
,
1792 &io_parms
, &bytes_written
, iov
, 1);
1794 if (rc
|| (bytes_written
== 0)) {
1802 spin_lock(&d_inode(dentry
)->i_lock
);
1803 cifs_update_eof(cifsi
, *offset
, bytes_written
);
1804 spin_unlock(&d_inode(dentry
)->i_lock
);
1805 *offset
+= bytes_written
;
1809 cifs_stats_bytes_written(tcon
, total_written
);
1811 if (total_written
> 0) {
1812 spin_lock(&d_inode(dentry
)->i_lock
);
1813 if (*offset
> d_inode(dentry
)->i_size
)
1814 i_size_write(d_inode(dentry
), *offset
);
1815 spin_unlock(&d_inode(dentry
)->i_lock
);
1817 mark_inode_dirty_sync(d_inode(dentry
));
1819 return total_written
;
1822 struct cifsFileInfo
*find_readable_file(struct cifsInodeInfo
*cifs_inode
,
1825 struct cifsFileInfo
*open_file
= NULL
;
1826 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1827 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
1829 /* only filter by fsuid on multiuser mounts */
1830 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1833 spin_lock(&tcon
->open_file_lock
);
1834 /* we could simply get the first_list_entry since write-only entries
1835 are always at the end of the list but since the first entry might
1836 have a close pending, we go through the whole list */
1837 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1838 if (fsuid_only
&& !uid_eq(open_file
->uid
, current_fsuid()))
1840 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_READ
) {
1841 if (!open_file
->invalidHandle
) {
1842 /* found a good file */
1843 /* lock it so it will not be closed on us */
1844 cifsFileInfo_get(open_file
);
1845 spin_unlock(&tcon
->open_file_lock
);
1847 } /* else might as well continue, and look for
1848 another, or simply have the caller reopen it
1849 again rather than trying to fix this handle */
1850 } else /* write only file */
1851 break; /* write only files are last so must be done */
1853 spin_unlock(&tcon
->open_file_lock
);
1857 /* Return -EBADF if no handle is found and general rc otherwise */
1859 cifs_get_writable_file(struct cifsInodeInfo
*cifs_inode
, bool fsuid_only
,
1860 struct cifsFileInfo
**ret_file
)
1862 struct cifsFileInfo
*open_file
, *inv_file
= NULL
;
1863 struct cifs_sb_info
*cifs_sb
;
1864 struct cifs_tcon
*tcon
;
1865 bool any_available
= false;
1867 unsigned int refind
= 0;
1872 * Having a null inode here (because mapping->host was set to zero by
1873 * the VFS or MM) should not happen but we had reports of on oops (due
1874 * to it being zero) during stress testcases so we need to check for it
1877 if (cifs_inode
== NULL
) {
1878 cifs_dbg(VFS
, "Null inode passed to cifs_writeable_file\n");
1883 cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1884 tcon
= cifs_sb_master_tcon(cifs_sb
);
1886 /* only filter by fsuid on multiuser mounts */
1887 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1890 spin_lock(&tcon
->open_file_lock
);
1892 if (refind
> MAX_REOPEN_ATT
) {
1893 spin_unlock(&tcon
->open_file_lock
);
1896 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1897 if (!any_available
&& open_file
->pid
!= current
->tgid
)
1899 if (fsuid_only
&& !uid_eq(open_file
->uid
, current_fsuid()))
1901 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_WRITE
) {
1902 if (!open_file
->invalidHandle
) {
1903 /* found a good writable file */
1904 cifsFileInfo_get(open_file
);
1905 spin_unlock(&tcon
->open_file_lock
);
1906 *ret_file
= open_file
;
1910 inv_file
= open_file
;
1914 /* couldn't find useable FH with same pid, try any available */
1915 if (!any_available
) {
1916 any_available
= true;
1917 goto refind_writable
;
1921 any_available
= false;
1922 cifsFileInfo_get(inv_file
);
1925 spin_unlock(&tcon
->open_file_lock
);
1928 rc
= cifs_reopen_file(inv_file
, false);
1930 *ret_file
= inv_file
;
1934 spin_lock(&tcon
->open_file_lock
);
1935 list_move_tail(&inv_file
->flist
, &cifs_inode
->openFileList
);
1936 spin_unlock(&tcon
->open_file_lock
);
1937 cifsFileInfo_put(inv_file
);
1940 spin_lock(&tcon
->open_file_lock
);
1941 goto refind_writable
;
1947 struct cifsFileInfo
*
1948 find_writable_file(struct cifsInodeInfo
*cifs_inode
, bool fsuid_only
)
1950 struct cifsFileInfo
*cfile
;
1953 rc
= cifs_get_writable_file(cifs_inode
, fsuid_only
, &cfile
);
1955 cifs_dbg(FYI
, "couldn't find writable handle rc=%d", rc
);
1960 static int cifs_partialpagewrite(struct page
*page
, unsigned from
, unsigned to
)
1962 struct address_space
*mapping
= page
->mapping
;
1963 loff_t offset
= (loff_t
)page
->index
<< PAGE_SHIFT
;
1966 int bytes_written
= 0;
1967 struct inode
*inode
;
1968 struct cifsFileInfo
*open_file
;
1970 if (!mapping
|| !mapping
->host
)
1973 inode
= page
->mapping
->host
;
1975 offset
+= (loff_t
)from
;
1976 write_data
= kmap(page
);
1979 if ((to
> PAGE_SIZE
) || (from
> to
)) {
1984 /* racing with truncate? */
1985 if (offset
> mapping
->host
->i_size
) {
1987 return 0; /* don't care */
1990 /* check to make sure that we are not extending the file */
1991 if (mapping
->host
->i_size
- offset
< (loff_t
)to
)
1992 to
= (unsigned)(mapping
->host
->i_size
- offset
);
1994 rc
= cifs_get_writable_file(CIFS_I(mapping
->host
), false, &open_file
);
1996 bytes_written
= cifs_write(open_file
, open_file
->pid
,
1997 write_data
, to
- from
, &offset
);
1998 cifsFileInfo_put(open_file
);
1999 /* Does mm or vfs already set times? */
2000 inode
->i_atime
= inode
->i_mtime
= current_time(inode
);
2001 if ((bytes_written
> 0) && (offset
))
2003 else if (bytes_written
< 0)
2008 cifs_dbg(FYI
, "No writable handle for write page rc=%d\n", rc
);
2009 if (!is_retryable_error(rc
))
2017 static struct cifs_writedata
*
2018 wdata_alloc_and_fillpages(pgoff_t tofind
, struct address_space
*mapping
,
2019 pgoff_t end
, pgoff_t
*index
,
2020 unsigned int *found_pages
)
2022 struct cifs_writedata
*wdata
;
2024 wdata
= cifs_writedata_alloc((unsigned int)tofind
,
2025 cifs_writev_complete
);
2029 *found_pages
= find_get_pages_range_tag(mapping
, index
, end
,
2030 PAGECACHE_TAG_DIRTY
, tofind
, wdata
->pages
);
2035 wdata_prepare_pages(struct cifs_writedata
*wdata
, unsigned int found_pages
,
2036 struct address_space
*mapping
,
2037 struct writeback_control
*wbc
,
2038 pgoff_t end
, pgoff_t
*index
, pgoff_t
*next
, bool *done
)
2040 unsigned int nr_pages
= 0, i
;
2043 for (i
= 0; i
< found_pages
; i
++) {
2044 page
= wdata
->pages
[i
];
2046 * At this point we hold neither the i_pages lock nor the
2047 * page lock: the page may be truncated or invalidated
2048 * (changing page->mapping to NULL), or even swizzled
2049 * back from swapper_space to tmpfs file mapping
2054 else if (!trylock_page(page
))
2057 if (unlikely(page
->mapping
!= mapping
)) {
2062 if (!wbc
->range_cyclic
&& page
->index
> end
) {
2068 if (*next
&& (page
->index
!= *next
)) {
2069 /* Not next consecutive page */
2074 if (wbc
->sync_mode
!= WB_SYNC_NONE
)
2075 wait_on_page_writeback(page
);
2077 if (PageWriteback(page
) ||
2078 !clear_page_dirty_for_io(page
)) {
2084 * This actually clears the dirty bit in the radix tree.
2085 * See cifs_writepage() for more commentary.
2087 set_page_writeback(page
);
2088 if (page_offset(page
) >= i_size_read(mapping
->host
)) {
2091 end_page_writeback(page
);
2095 wdata
->pages
[i
] = page
;
2096 *next
= page
->index
+ 1;
2100 /* reset index to refind any pages skipped */
2102 *index
= wdata
->pages
[0]->index
+ 1;
2104 /* put any pages we aren't going to use */
2105 for (i
= nr_pages
; i
< found_pages
; i
++) {
2106 put_page(wdata
->pages
[i
]);
2107 wdata
->pages
[i
] = NULL
;
2114 wdata_send_pages(struct cifs_writedata
*wdata
, unsigned int nr_pages
,
2115 struct address_space
*mapping
, struct writeback_control
*wbc
)
2118 struct TCP_Server_Info
*server
=
2119 tlink_tcon(wdata
->cfile
->tlink
)->ses
->server
;
2121 wdata
->sync_mode
= wbc
->sync_mode
;
2122 wdata
->nr_pages
= nr_pages
;
2123 wdata
->offset
= page_offset(wdata
->pages
[0]);
2124 wdata
->pagesz
= PAGE_SIZE
;
2125 wdata
->tailsz
= min(i_size_read(mapping
->host
) -
2126 page_offset(wdata
->pages
[nr_pages
- 1]),
2128 wdata
->bytes
= ((nr_pages
- 1) * PAGE_SIZE
) + wdata
->tailsz
;
2129 wdata
->pid
= wdata
->cfile
->pid
;
2131 rc
= adjust_credits(server
, &wdata
->credits
, wdata
->bytes
);
2135 if (wdata
->cfile
->invalidHandle
)
2138 rc
= server
->ops
->async_writev(wdata
, cifs_writedata_release
);
2143 static int cifs_writepages(struct address_space
*mapping
,
2144 struct writeback_control
*wbc
)
2146 struct inode
*inode
= mapping
->host
;
2147 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2148 struct TCP_Server_Info
*server
;
2149 bool done
= false, scanned
= false, range_whole
= false;
2151 struct cifs_writedata
*wdata
;
2152 struct cifsFileInfo
*cfile
= NULL
;
2158 * If wsize is smaller than the page cache size, default to writing
2159 * one page at a time via cifs_writepage
2161 if (cifs_sb
->wsize
< PAGE_SIZE
)
2162 return generic_writepages(mapping
, wbc
);
2165 if (wbc
->range_cyclic
) {
2166 index
= mapping
->writeback_index
; /* Start from prev offset */
2169 index
= wbc
->range_start
>> PAGE_SHIFT
;
2170 end
= wbc
->range_end
>> PAGE_SHIFT
;
2171 if (wbc
->range_start
== 0 && wbc
->range_end
== LLONG_MAX
)
2175 server
= cifs_sb_master_tcon(cifs_sb
)->ses
->server
;
2177 while (!done
&& index
<= end
) {
2178 unsigned int i
, nr_pages
, found_pages
, wsize
;
2179 pgoff_t next
= 0, tofind
, saved_index
= index
;
2180 struct cifs_credits credits_on_stack
;
2181 struct cifs_credits
*credits
= &credits_on_stack
;
2182 int get_file_rc
= 0;
2185 cifsFileInfo_put(cfile
);
2187 rc
= cifs_get_writable_file(CIFS_I(inode
), false, &cfile
);
2189 /* in case of an error store it to return later */
2193 rc
= server
->ops
->wait_mtu_credits(server
, cifs_sb
->wsize
,
2200 tofind
= min((wsize
/ PAGE_SIZE
) - 1, end
- index
) + 1;
2202 wdata
= wdata_alloc_and_fillpages(tofind
, mapping
, end
, &index
,
2207 add_credits_and_wake_if(server
, credits
, 0);
2211 if (found_pages
== 0) {
2212 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2213 add_credits_and_wake_if(server
, credits
, 0);
2217 nr_pages
= wdata_prepare_pages(wdata
, found_pages
, mapping
, wbc
,
2218 end
, &index
, &next
, &done
);
2220 /* nothing to write? */
2221 if (nr_pages
== 0) {
2222 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2223 add_credits_and_wake_if(server
, credits
, 0);
2227 wdata
->credits
= credits_on_stack
;
2228 wdata
->cfile
= cfile
;
2231 if (!wdata
->cfile
) {
2232 cifs_dbg(VFS
, "No writable handle in writepages rc=%d\n",
2234 if (is_retryable_error(get_file_rc
))
2239 rc
= wdata_send_pages(wdata
, nr_pages
, mapping
, wbc
);
2241 for (i
= 0; i
< nr_pages
; ++i
)
2242 unlock_page(wdata
->pages
[i
]);
2244 /* send failure -- clean up the mess */
2246 add_credits_and_wake_if(server
, &wdata
->credits
, 0);
2247 for (i
= 0; i
< nr_pages
; ++i
) {
2248 if (is_retryable_error(rc
))
2249 redirty_page_for_writepage(wbc
,
2252 SetPageError(wdata
->pages
[i
]);
2253 end_page_writeback(wdata
->pages
[i
]);
2254 put_page(wdata
->pages
[i
]);
2256 if (!is_retryable_error(rc
))
2257 mapping_set_error(mapping
, rc
);
2259 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2261 if (wbc
->sync_mode
== WB_SYNC_ALL
&& rc
== -EAGAIN
) {
2262 index
= saved_index
;
2266 /* Return immediately if we received a signal during writing */
2267 if (is_interrupt_error(rc
)) {
2272 if (rc
!= 0 && saved_rc
== 0)
2275 wbc
->nr_to_write
-= nr_pages
;
2276 if (wbc
->nr_to_write
<= 0)
2282 if (!scanned
&& !done
) {
2284 * We hit the last page and there is more work to be done: wrap
2285 * back to the start of the file
2295 if (wbc
->range_cyclic
|| (range_whole
&& wbc
->nr_to_write
> 0))
2296 mapping
->writeback_index
= index
;
2299 cifsFileInfo_put(cfile
);
2305 cifs_writepage_locked(struct page
*page
, struct writeback_control
*wbc
)
2311 /* BB add check for wbc flags */
2313 if (!PageUptodate(page
))
2314 cifs_dbg(FYI
, "ppw - page not up to date\n");
2317 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2319 * A writepage() implementation always needs to do either this,
2320 * or re-dirty the page with "redirty_page_for_writepage()" in
2321 * the case of a failure.
2323 * Just unlocking the page will cause the radix tree tag-bits
2324 * to fail to update with the state of the page correctly.
2326 set_page_writeback(page
);
2328 rc
= cifs_partialpagewrite(page
, 0, PAGE_SIZE
);
2329 if (is_retryable_error(rc
)) {
2330 if (wbc
->sync_mode
== WB_SYNC_ALL
&& rc
== -EAGAIN
)
2332 redirty_page_for_writepage(wbc
, page
);
2333 } else if (rc
!= 0) {
2335 mapping_set_error(page
->mapping
, rc
);
2337 SetPageUptodate(page
);
2339 end_page_writeback(page
);
2345 static int cifs_writepage(struct page
*page
, struct writeback_control
*wbc
)
2347 int rc
= cifs_writepage_locked(page
, wbc
);
2352 static int cifs_write_end(struct file
*file
, struct address_space
*mapping
,
2353 loff_t pos
, unsigned len
, unsigned copied
,
2354 struct page
*page
, void *fsdata
)
2357 struct inode
*inode
= mapping
->host
;
2358 struct cifsFileInfo
*cfile
= file
->private_data
;
2359 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->dentry
->d_sb
);
2362 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
2365 pid
= current
->tgid
;
2367 cifs_dbg(FYI
, "write_end for page %p from pos %lld with %d bytes\n",
2370 if (PageChecked(page
)) {
2372 SetPageUptodate(page
);
2373 ClearPageChecked(page
);
2374 } else if (!PageUptodate(page
) && copied
== PAGE_SIZE
)
2375 SetPageUptodate(page
);
2377 if (!PageUptodate(page
)) {
2379 unsigned offset
= pos
& (PAGE_SIZE
- 1);
2383 /* this is probably better than directly calling
2384 partialpage_write since in this function the file handle is
2385 known which we might as well leverage */
2386 /* BB check if anything else missing out of ppw
2387 such as updating last write time */
2388 page_data
= kmap(page
);
2389 rc
= cifs_write(cfile
, pid
, page_data
+ offset
, copied
, &pos
);
2390 /* if (rc < 0) should we set writebehind rc? */
2397 set_page_dirty(page
);
2401 spin_lock(&inode
->i_lock
);
2402 if (pos
> inode
->i_size
)
2403 i_size_write(inode
, pos
);
2404 spin_unlock(&inode
->i_lock
);
2413 int cifs_strict_fsync(struct file
*file
, loff_t start
, loff_t end
,
2418 struct cifs_tcon
*tcon
;
2419 struct TCP_Server_Info
*server
;
2420 struct cifsFileInfo
*smbfile
= file
->private_data
;
2421 struct inode
*inode
= file_inode(file
);
2422 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2424 rc
= file_write_and_wait_range(file
, start
, end
);
2431 cifs_dbg(FYI
, "Sync file - name: %pD datasync: 0x%x\n",
2434 if (!CIFS_CACHE_READ(CIFS_I(inode
))) {
2435 rc
= cifs_zap_mapping(inode
);
2437 cifs_dbg(FYI
, "rc: %d during invalidate phase\n", rc
);
2438 rc
= 0; /* don't care about it in fsync */
2442 tcon
= tlink_tcon(smbfile
->tlink
);
2443 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
)) {
2444 server
= tcon
->ses
->server
;
2445 if (server
->ops
->flush
)
2446 rc
= server
->ops
->flush(xid
, tcon
, &smbfile
->fid
);
2452 inode_unlock(inode
);
2456 int cifs_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
2460 struct cifs_tcon
*tcon
;
2461 struct TCP_Server_Info
*server
;
2462 struct cifsFileInfo
*smbfile
= file
->private_data
;
2463 struct cifs_sb_info
*cifs_sb
= CIFS_FILE_SB(file
);
2464 struct inode
*inode
= file
->f_mapping
->host
;
2466 rc
= file_write_and_wait_range(file
, start
, end
);
2473 cifs_dbg(FYI
, "Sync file - name: %pD datasync: 0x%x\n",
2476 tcon
= tlink_tcon(smbfile
->tlink
);
2477 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
)) {
2478 server
= tcon
->ses
->server
;
2479 if (server
->ops
->flush
)
2480 rc
= server
->ops
->flush(xid
, tcon
, &smbfile
->fid
);
2486 inode_unlock(inode
);
2491 * As file closes, flush all cached write data for this inode checking
2492 * for write behind errors.
2494 int cifs_flush(struct file
*file
, fl_owner_t id
)
2496 struct inode
*inode
= file_inode(file
);
2499 if (file
->f_mode
& FMODE_WRITE
)
2500 rc
= filemap_write_and_wait(inode
->i_mapping
);
2502 cifs_dbg(FYI
, "Flush inode %p file %p rc %d\n", inode
, file
, rc
);
2508 cifs_write_allocate_pages(struct page
**pages
, unsigned long num_pages
)
2513 for (i
= 0; i
< num_pages
; i
++) {
2514 pages
[i
] = alloc_page(GFP_KERNEL
|__GFP_HIGHMEM
);
2517 * save number of pages we have already allocated and
2518 * return with ENOMEM error
2527 for (i
= 0; i
< num_pages
; i
++)
2534 size_t get_numpages(const size_t wsize
, const size_t len
, size_t *cur_len
)
2539 clen
= min_t(const size_t, len
, wsize
);
2540 num_pages
= DIV_ROUND_UP(clen
, PAGE_SIZE
);
2549 cifs_uncached_writedata_release(struct kref
*refcount
)
2552 struct cifs_writedata
*wdata
= container_of(refcount
,
2553 struct cifs_writedata
, refcount
);
2555 kref_put(&wdata
->ctx
->refcount
, cifs_aio_ctx_release
);
2556 for (i
= 0; i
< wdata
->nr_pages
; i
++)
2557 put_page(wdata
->pages
[i
]);
2558 cifs_writedata_release(refcount
);
2561 static void collect_uncached_write_data(struct cifs_aio_ctx
*ctx
);
2564 cifs_uncached_writev_complete(struct work_struct
*work
)
2566 struct cifs_writedata
*wdata
= container_of(work
,
2567 struct cifs_writedata
, work
);
2568 struct inode
*inode
= d_inode(wdata
->cfile
->dentry
);
2569 struct cifsInodeInfo
*cifsi
= CIFS_I(inode
);
2571 spin_lock(&inode
->i_lock
);
2572 cifs_update_eof(cifsi
, wdata
->offset
, wdata
->bytes
);
2573 if (cifsi
->server_eof
> inode
->i_size
)
2574 i_size_write(inode
, cifsi
->server_eof
);
2575 spin_unlock(&inode
->i_lock
);
2577 complete(&wdata
->done
);
2578 collect_uncached_write_data(wdata
->ctx
);
2579 /* the below call can possibly free the last ref to aio ctx */
2580 kref_put(&wdata
->refcount
, cifs_uncached_writedata_release
);
2584 wdata_fill_from_iovec(struct cifs_writedata
*wdata
, struct iov_iter
*from
,
2585 size_t *len
, unsigned long *num_pages
)
2587 size_t save_len
, copied
, bytes
, cur_len
= *len
;
2588 unsigned long i
, nr_pages
= *num_pages
;
2591 for (i
= 0; i
< nr_pages
; i
++) {
2592 bytes
= min_t(const size_t, cur_len
, PAGE_SIZE
);
2593 copied
= copy_page_from_iter(wdata
->pages
[i
], 0, bytes
, from
);
2596 * If we didn't copy as much as we expected, then that
2597 * may mean we trod into an unmapped area. Stop copying
2598 * at that point. On the next pass through the big
2599 * loop, we'll likely end up getting a zero-length
2600 * write and bailing out of it.
2605 cur_len
= save_len
- cur_len
;
2609 * If we have no data to send, then that probably means that
2610 * the copy above failed altogether. That's most likely because
2611 * the address in the iovec was bogus. Return -EFAULT and let
2612 * the caller free anything we allocated and bail out.
2618 * i + 1 now represents the number of pages we actually used in
2619 * the copy phase above.
2626 cifs_resend_wdata(struct cifs_writedata
*wdata
, struct list_head
*wdata_list
,
2627 struct cifs_aio_ctx
*ctx
)
2630 struct cifs_credits credits
;
2632 struct TCP_Server_Info
*server
=
2633 tlink_tcon(wdata
->cfile
->tlink
)->ses
->server
;
2636 if (wdata
->cfile
->invalidHandle
) {
2637 rc
= cifs_reopen_file(wdata
->cfile
, false);
2646 * Wait for credits to resend this wdata.
2647 * Note: we are attempting to resend the whole wdata not in
2651 rc
= server
->ops
->wait_mtu_credits(server
, wdata
->bytes
,
2656 if (wsize
< wdata
->bytes
) {
2657 add_credits_and_wake_if(server
, &credits
, 0);
2660 } while (wsize
< wdata
->bytes
);
2661 wdata
->credits
= credits
;
2663 rc
= adjust_credits(server
, &wdata
->credits
, wdata
->bytes
);
2666 if (wdata
->cfile
->invalidHandle
)
2669 rc
= server
->ops
->async_writev(wdata
,
2670 cifs_uncached_writedata_release
);
2673 /* If the write was successfully sent, we are done */
2675 list_add_tail(&wdata
->list
, wdata_list
);
2679 /* Roll back credits and retry if needed */
2680 add_credits_and_wake_if(server
, &wdata
->credits
, 0);
2681 } while (rc
== -EAGAIN
);
2684 kref_put(&wdata
->refcount
, cifs_uncached_writedata_release
);
2689 cifs_write_from_iter(loff_t offset
, size_t len
, struct iov_iter
*from
,
2690 struct cifsFileInfo
*open_file
,
2691 struct cifs_sb_info
*cifs_sb
, struct list_head
*wdata_list
,
2692 struct cifs_aio_ctx
*ctx
)
2696 unsigned long nr_pages
, num_pages
, i
;
2697 struct cifs_writedata
*wdata
;
2698 struct iov_iter saved_from
= *from
;
2699 loff_t saved_offset
= offset
;
2701 struct TCP_Server_Info
*server
;
2702 struct page
**pagevec
;
2706 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
2707 pid
= open_file
->pid
;
2709 pid
= current
->tgid
;
2711 server
= tlink_tcon(open_file
->tlink
)->ses
->server
;
2716 struct cifs_credits credits_on_stack
;
2717 struct cifs_credits
*credits
= &credits_on_stack
;
2719 if (open_file
->invalidHandle
) {
2720 rc
= cifs_reopen_file(open_file
, false);
2727 rc
= server
->ops
->wait_mtu_credits(server
, cifs_sb
->wsize
,
2732 cur_len
= min_t(const size_t, len
, wsize
);
2734 if (ctx
->direct_io
) {
2737 result
= iov_iter_get_pages_alloc(
2738 from
, &pagevec
, cur_len
, &start
);
2741 "direct_writev couldn't get user pages "
2742 "(rc=%zd) iter type %d iov_offset %zd "
2745 from
->iov_offset
, from
->count
);
2749 add_credits_and_wake_if(server
, credits
, 0);
2752 cur_len
= (size_t)result
;
2753 iov_iter_advance(from
, cur_len
);
2756 (cur_len
+ start
+ PAGE_SIZE
- 1) / PAGE_SIZE
;
2758 wdata
= cifs_writedata_direct_alloc(pagevec
,
2759 cifs_uncached_writev_complete
);
2762 add_credits_and_wake_if(server
, credits
, 0);
2767 wdata
->page_offset
= start
;
2770 cur_len
- (PAGE_SIZE
- start
) -
2771 (nr_pages
- 2) * PAGE_SIZE
:
2774 nr_pages
= get_numpages(wsize
, len
, &cur_len
);
2775 wdata
= cifs_writedata_alloc(nr_pages
,
2776 cifs_uncached_writev_complete
);
2779 add_credits_and_wake_if(server
, credits
, 0);
2783 rc
= cifs_write_allocate_pages(wdata
->pages
, nr_pages
);
2785 kvfree(wdata
->pages
);
2787 add_credits_and_wake_if(server
, credits
, 0);
2791 num_pages
= nr_pages
;
2792 rc
= wdata_fill_from_iovec(
2793 wdata
, from
, &cur_len
, &num_pages
);
2795 for (i
= 0; i
< nr_pages
; i
++)
2796 put_page(wdata
->pages
[i
]);
2797 kvfree(wdata
->pages
);
2799 add_credits_and_wake_if(server
, credits
, 0);
2804 * Bring nr_pages down to the number of pages we
2805 * actually used, and free any pages that we didn't use.
2807 for ( ; nr_pages
> num_pages
; nr_pages
--)
2808 put_page(wdata
->pages
[nr_pages
- 1]);
2810 wdata
->tailsz
= cur_len
- ((nr_pages
- 1) * PAGE_SIZE
);
2813 wdata
->sync_mode
= WB_SYNC_ALL
;
2814 wdata
->nr_pages
= nr_pages
;
2815 wdata
->offset
= (__u64
)offset
;
2816 wdata
->cfile
= cifsFileInfo_get(open_file
);
2818 wdata
->bytes
= cur_len
;
2819 wdata
->pagesz
= PAGE_SIZE
;
2820 wdata
->credits
= credits_on_stack
;
2822 kref_get(&ctx
->refcount
);
2824 rc
= adjust_credits(server
, &wdata
->credits
, wdata
->bytes
);
2827 if (wdata
->cfile
->invalidHandle
)
2830 rc
= server
->ops
->async_writev(wdata
,
2831 cifs_uncached_writedata_release
);
2835 add_credits_and_wake_if(server
, &wdata
->credits
, 0);
2836 kref_put(&wdata
->refcount
,
2837 cifs_uncached_writedata_release
);
2838 if (rc
== -EAGAIN
) {
2840 iov_iter_advance(from
, offset
- saved_offset
);
2846 list_add_tail(&wdata
->list
, wdata_list
);
2855 static void collect_uncached_write_data(struct cifs_aio_ctx
*ctx
)
2857 struct cifs_writedata
*wdata
, *tmp
;
2858 struct cifs_tcon
*tcon
;
2859 struct cifs_sb_info
*cifs_sb
;
2860 struct dentry
*dentry
= ctx
->cfile
->dentry
;
2864 tcon
= tlink_tcon(ctx
->cfile
->tlink
);
2865 cifs_sb
= CIFS_SB(dentry
->d_sb
);
2867 mutex_lock(&ctx
->aio_mutex
);
2869 if (list_empty(&ctx
->list
)) {
2870 mutex_unlock(&ctx
->aio_mutex
);
2876 * Wait for and collect replies for any successful sends in order of
2877 * increasing offset. Once an error is hit, then return without waiting
2878 * for any more replies.
2881 list_for_each_entry_safe(wdata
, tmp
, &ctx
->list
, list
) {
2883 if (!try_wait_for_completion(&wdata
->done
)) {
2884 mutex_unlock(&ctx
->aio_mutex
);
2891 ctx
->total_len
+= wdata
->bytes
;
2893 /* resend call if it's a retryable error */
2894 if (rc
== -EAGAIN
) {
2895 struct list_head tmp_list
;
2896 struct iov_iter tmp_from
= ctx
->iter
;
2898 INIT_LIST_HEAD(&tmp_list
);
2899 list_del_init(&wdata
->list
);
2902 rc
= cifs_resend_wdata(
2903 wdata
, &tmp_list
, ctx
);
2905 iov_iter_advance(&tmp_from
,
2906 wdata
->offset
- ctx
->pos
);
2908 rc
= cifs_write_from_iter(wdata
->offset
,
2909 wdata
->bytes
, &tmp_from
,
2910 ctx
->cfile
, cifs_sb
, &tmp_list
,
2913 kref_put(&wdata
->refcount
,
2914 cifs_uncached_writedata_release
);
2917 list_splice(&tmp_list
, &ctx
->list
);
2921 list_del_init(&wdata
->list
);
2922 kref_put(&wdata
->refcount
, cifs_uncached_writedata_release
);
2925 if (!ctx
->direct_io
)
2926 for (i
= 0; i
< ctx
->npages
; i
++)
2927 put_page(ctx
->bv
[i
].bv_page
);
2929 cifs_stats_bytes_written(tcon
, ctx
->total_len
);
2930 set_bit(CIFS_INO_INVALID_MAPPING
, &CIFS_I(dentry
->d_inode
)->flags
);
2932 ctx
->rc
= (rc
== 0) ? ctx
->total_len
: rc
;
2934 mutex_unlock(&ctx
->aio_mutex
);
2936 if (ctx
->iocb
&& ctx
->iocb
->ki_complete
)
2937 ctx
->iocb
->ki_complete(ctx
->iocb
, ctx
->rc
, 0);
2939 complete(&ctx
->done
);
2942 static ssize_t
__cifs_writev(
2943 struct kiocb
*iocb
, struct iov_iter
*from
, bool direct
)
2945 struct file
*file
= iocb
->ki_filp
;
2946 ssize_t total_written
= 0;
2947 struct cifsFileInfo
*cfile
;
2948 struct cifs_tcon
*tcon
;
2949 struct cifs_sb_info
*cifs_sb
;
2950 struct cifs_aio_ctx
*ctx
;
2951 struct iov_iter saved_from
= *from
;
2952 size_t len
= iov_iter_count(from
);
2956 * iov_iter_get_pages_alloc doesn't work with ITER_KVEC.
2957 * In this case, fall back to non-direct write function.
2958 * this could be improved by getting pages directly in ITER_KVEC
2960 if (direct
&& from
->type
& ITER_KVEC
) {
2961 cifs_dbg(FYI
, "use non-direct cifs_writev for kvec I/O\n");
2965 rc
= generic_write_checks(iocb
, from
);
2969 cifs_sb
= CIFS_FILE_SB(file
);
2970 cfile
= file
->private_data
;
2971 tcon
= tlink_tcon(cfile
->tlink
);
2973 if (!tcon
->ses
->server
->ops
->async_writev
)
2976 ctx
= cifs_aio_ctx_alloc();
2980 ctx
->cfile
= cifsFileInfo_get(cfile
);
2982 if (!is_sync_kiocb(iocb
))
2985 ctx
->pos
= iocb
->ki_pos
;
2988 ctx
->direct_io
= true;
2992 rc
= setup_aio_ctx_iter(ctx
, from
, WRITE
);
2994 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
2999 /* grab a lock here due to read response handlers can access ctx */
3000 mutex_lock(&ctx
->aio_mutex
);
3002 rc
= cifs_write_from_iter(iocb
->ki_pos
, ctx
->len
, &saved_from
,
3003 cfile
, cifs_sb
, &ctx
->list
, ctx
);
3006 * If at least one write was successfully sent, then discard any rc
3007 * value from the later writes. If the other write succeeds, then
3008 * we'll end up returning whatever was written. If it fails, then
3009 * we'll get a new rc value from that.
3011 if (!list_empty(&ctx
->list
))
3014 mutex_unlock(&ctx
->aio_mutex
);
3017 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
3021 if (!is_sync_kiocb(iocb
)) {
3022 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
3023 return -EIOCBQUEUED
;
3026 rc
= wait_for_completion_killable(&ctx
->done
);
3028 mutex_lock(&ctx
->aio_mutex
);
3029 ctx
->rc
= rc
= -EINTR
;
3030 total_written
= ctx
->total_len
;
3031 mutex_unlock(&ctx
->aio_mutex
);
3034 total_written
= ctx
->total_len
;
3037 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
3039 if (unlikely(!total_written
))
3042 iocb
->ki_pos
+= total_written
;
3043 return total_written
;
3046 ssize_t
cifs_direct_writev(struct kiocb
*iocb
, struct iov_iter
*from
)
3048 return __cifs_writev(iocb
, from
, true);
3051 ssize_t
cifs_user_writev(struct kiocb
*iocb
, struct iov_iter
*from
)
3053 return __cifs_writev(iocb
, from
, false);
3057 cifs_writev(struct kiocb
*iocb
, struct iov_iter
*from
)
3059 struct file
*file
= iocb
->ki_filp
;
3060 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)file
->private_data
;
3061 struct inode
*inode
= file
->f_mapping
->host
;
3062 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
3063 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
3068 * We need to hold the sem to be sure nobody modifies lock list
3069 * with a brlock that prevents writing.
3071 down_read(&cinode
->lock_sem
);
3073 rc
= generic_write_checks(iocb
, from
);
3077 if (!cifs_find_lock_conflict(cfile
, iocb
->ki_pos
, iov_iter_count(from
),
3078 server
->vals
->exclusive_lock_type
, 0,
3079 NULL
, CIFS_WRITE_OP
))
3080 rc
= __generic_file_write_iter(iocb
, from
);
3084 up_read(&cinode
->lock_sem
);
3085 inode_unlock(inode
);
3088 rc
= generic_write_sync(iocb
, rc
);
3093 cifs_strict_writev(struct kiocb
*iocb
, struct iov_iter
*from
)
3095 struct inode
*inode
= file_inode(iocb
->ki_filp
);
3096 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
3097 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
3098 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)
3099 iocb
->ki_filp
->private_data
;
3100 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
3103 written
= cifs_get_writer(cinode
);
3107 if (CIFS_CACHE_WRITE(cinode
)) {
3108 if (cap_unix(tcon
->ses
) &&
3109 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
))
3110 && ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0)) {
3111 written
= generic_file_write_iter(iocb
, from
);
3114 written
= cifs_writev(iocb
, from
);
3118 * For non-oplocked files in strict cache mode we need to write the data
3119 * to the server exactly from the pos to pos+len-1 rather than flush all
3120 * affected pages because it may cause a error with mandatory locks on
3121 * these pages but not on the region from pos to ppos+len-1.
3123 written
= cifs_user_writev(iocb
, from
);
3124 if (CIFS_CACHE_READ(cinode
)) {
3126 * We have read level caching and we have just sent a write
3127 * request to the server thus making data in the cache stale.
3128 * Zap the cache and set oplock/lease level to NONE to avoid
3129 * reading stale data from the cache. All subsequent read
3130 * operations will read new data from the server.
3132 cifs_zap_mapping(inode
);
3133 cifs_dbg(FYI
, "Set Oplock/Lease to NONE for inode=%p after write\n",
3138 cifs_put_writer(cinode
);
3142 static struct cifs_readdata
*
3143 cifs_readdata_direct_alloc(struct page
**pages
, work_func_t complete
)
3145 struct cifs_readdata
*rdata
;
3147 rdata
= kzalloc(sizeof(*rdata
), GFP_KERNEL
);
3148 if (rdata
!= NULL
) {
3149 rdata
->pages
= pages
;
3150 kref_init(&rdata
->refcount
);
3151 INIT_LIST_HEAD(&rdata
->list
);
3152 init_completion(&rdata
->done
);
3153 INIT_WORK(&rdata
->work
, complete
);
3159 static struct cifs_readdata
*
3160 cifs_readdata_alloc(unsigned int nr_pages
, work_func_t complete
)
3162 struct page
**pages
=
3163 kcalloc(nr_pages
, sizeof(struct page
*), GFP_KERNEL
);
3164 struct cifs_readdata
*ret
= NULL
;
3167 ret
= cifs_readdata_direct_alloc(pages
, complete
);
3176 cifs_readdata_release(struct kref
*refcount
)
3178 struct cifs_readdata
*rdata
= container_of(refcount
,
3179 struct cifs_readdata
, refcount
);
3180 #ifdef CONFIG_CIFS_SMB_DIRECT
3182 smbd_deregister_mr(rdata
->mr
);
3187 cifsFileInfo_put(rdata
->cfile
);
3189 kvfree(rdata
->pages
);
3194 cifs_read_allocate_pages(struct cifs_readdata
*rdata
, unsigned int nr_pages
)
3200 for (i
= 0; i
< nr_pages
; i
++) {
3201 page
= alloc_page(GFP_KERNEL
|__GFP_HIGHMEM
);
3206 rdata
->pages
[i
] = page
;
3210 for (i
= 0; i
< nr_pages
; i
++) {
3211 put_page(rdata
->pages
[i
]);
3212 rdata
->pages
[i
] = NULL
;
3219 cifs_uncached_readdata_release(struct kref
*refcount
)
3221 struct cifs_readdata
*rdata
= container_of(refcount
,
3222 struct cifs_readdata
, refcount
);
3225 kref_put(&rdata
->ctx
->refcount
, cifs_aio_ctx_release
);
3226 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
3227 put_page(rdata
->pages
[i
]);
3229 cifs_readdata_release(refcount
);
3233 * cifs_readdata_to_iov - copy data from pages in response to an iovec
3234 * @rdata: the readdata response with list of pages holding data
3235 * @iter: destination for our data
3237 * This function copies data from a list of pages in a readdata response into
3238 * an array of iovecs. It will first calculate where the data should go
3239 * based on the info in the readdata and then copy the data into that spot.
3242 cifs_readdata_to_iov(struct cifs_readdata
*rdata
, struct iov_iter
*iter
)
3244 size_t remaining
= rdata
->got_bytes
;
3247 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
3248 struct page
*page
= rdata
->pages
[i
];
3249 size_t copy
= min_t(size_t, remaining
, PAGE_SIZE
);
3252 if (unlikely(iov_iter_is_pipe(iter
))) {
3253 void *addr
= kmap_atomic(page
);
3255 written
= copy_to_iter(addr
, copy
, iter
);
3256 kunmap_atomic(addr
);
3258 written
= copy_page_to_iter(page
, 0, copy
, iter
);
3259 remaining
-= written
;
3260 if (written
< copy
&& iov_iter_count(iter
) > 0)
3263 return remaining
? -EFAULT
: 0;
3266 static void collect_uncached_read_data(struct cifs_aio_ctx
*ctx
);
3269 cifs_uncached_readv_complete(struct work_struct
*work
)
3271 struct cifs_readdata
*rdata
= container_of(work
,
3272 struct cifs_readdata
, work
);
3274 complete(&rdata
->done
);
3275 collect_uncached_read_data(rdata
->ctx
);
3276 /* the below call can possibly free the last ref to aio ctx */
3277 kref_put(&rdata
->refcount
, cifs_uncached_readdata_release
);
3281 uncached_fill_pages(struct TCP_Server_Info
*server
,
3282 struct cifs_readdata
*rdata
, struct iov_iter
*iter
,
3287 unsigned int nr_pages
= rdata
->nr_pages
;
3288 unsigned int page_offset
= rdata
->page_offset
;
3290 rdata
->got_bytes
= 0;
3291 rdata
->tailsz
= PAGE_SIZE
;
3292 for (i
= 0; i
< nr_pages
; i
++) {
3293 struct page
*page
= rdata
->pages
[i
];
3295 unsigned int segment_size
= rdata
->pagesz
;
3298 segment_size
-= page_offset
;
3304 /* no need to hold page hostage */
3305 rdata
->pages
[i
] = NULL
;
3312 if (len
>= segment_size
)
3313 /* enough data to fill the page */
3316 rdata
->tailsz
= len
;
3320 result
= copy_page_from_iter(
3321 page
, page_offset
, n
, iter
);
3322 #ifdef CONFIG_CIFS_SMB_DIRECT
3327 result
= cifs_read_page_from_socket(
3328 server
, page
, page_offset
, n
);
3332 rdata
->got_bytes
+= result
;
3335 return rdata
->got_bytes
> 0 && result
!= -ECONNABORTED
?
3336 rdata
->got_bytes
: result
;
3340 cifs_uncached_read_into_pages(struct TCP_Server_Info
*server
,
3341 struct cifs_readdata
*rdata
, unsigned int len
)
3343 return uncached_fill_pages(server
, rdata
, NULL
, len
);
3347 cifs_uncached_copy_into_pages(struct TCP_Server_Info
*server
,
3348 struct cifs_readdata
*rdata
,
3349 struct iov_iter
*iter
)
3351 return uncached_fill_pages(server
, rdata
, iter
, iter
->count
);
3354 static int cifs_resend_rdata(struct cifs_readdata
*rdata
,
3355 struct list_head
*rdata_list
,
3356 struct cifs_aio_ctx
*ctx
)
3359 struct cifs_credits credits
;
3361 struct TCP_Server_Info
*server
=
3362 tlink_tcon(rdata
->cfile
->tlink
)->ses
->server
;
3365 if (rdata
->cfile
->invalidHandle
) {
3366 rc
= cifs_reopen_file(rdata
->cfile
, true);
3374 * Wait for credits to resend this rdata.
3375 * Note: we are attempting to resend the whole rdata not in
3379 rc
= server
->ops
->wait_mtu_credits(server
, rdata
->bytes
,
3385 if (rsize
< rdata
->bytes
) {
3386 add_credits_and_wake_if(server
, &credits
, 0);
3389 } while (rsize
< rdata
->bytes
);
3390 rdata
->credits
= credits
;
3392 rc
= adjust_credits(server
, &rdata
->credits
, rdata
->bytes
);
3394 if (rdata
->cfile
->invalidHandle
)
3397 rc
= server
->ops
->async_readv(rdata
);
3400 /* If the read was successfully sent, we are done */
3402 /* Add to aio pending list */
3403 list_add_tail(&rdata
->list
, rdata_list
);
3407 /* Roll back credits and retry if needed */
3408 add_credits_and_wake_if(server
, &rdata
->credits
, 0);
3409 } while (rc
== -EAGAIN
);
3412 kref_put(&rdata
->refcount
, cifs_uncached_readdata_release
);
3417 cifs_send_async_read(loff_t offset
, size_t len
, struct cifsFileInfo
*open_file
,
3418 struct cifs_sb_info
*cifs_sb
, struct list_head
*rdata_list
,
3419 struct cifs_aio_ctx
*ctx
)
3421 struct cifs_readdata
*rdata
;
3422 unsigned int npages
, rsize
;
3423 struct cifs_credits credits_on_stack
;
3424 struct cifs_credits
*credits
= &credits_on_stack
;
3428 struct TCP_Server_Info
*server
;
3429 struct page
**pagevec
;
3431 struct iov_iter direct_iov
= ctx
->iter
;
3433 server
= tlink_tcon(open_file
->tlink
)->ses
->server
;
3435 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
3436 pid
= open_file
->pid
;
3438 pid
= current
->tgid
;
3441 iov_iter_advance(&direct_iov
, offset
- ctx
->pos
);
3444 if (open_file
->invalidHandle
) {
3445 rc
= cifs_reopen_file(open_file
, true);
3452 rc
= server
->ops
->wait_mtu_credits(server
, cifs_sb
->rsize
,
3457 cur_len
= min_t(const size_t, len
, rsize
);
3459 if (ctx
->direct_io
) {
3462 result
= iov_iter_get_pages_alloc(
3463 &direct_iov
, &pagevec
,
3467 "couldn't get user pages (rc=%zd)"
3469 " iov_offset %zd count %zd\n",
3470 result
, direct_iov
.type
,
3471 direct_iov
.iov_offset
,
3476 add_credits_and_wake_if(server
, credits
, 0);
3479 cur_len
= (size_t)result
;
3480 iov_iter_advance(&direct_iov
, cur_len
);
3482 rdata
= cifs_readdata_direct_alloc(
3483 pagevec
, cifs_uncached_readv_complete
);
3485 add_credits_and_wake_if(server
, credits
, 0);
3490 npages
= (cur_len
+ start
+ PAGE_SIZE
-1) / PAGE_SIZE
;
3491 rdata
->page_offset
= start
;
3492 rdata
->tailsz
= npages
> 1 ?
3493 cur_len
-(PAGE_SIZE
-start
)-(npages
-2)*PAGE_SIZE
:
3498 npages
= DIV_ROUND_UP(cur_len
, PAGE_SIZE
);
3499 /* allocate a readdata struct */
3500 rdata
= cifs_readdata_alloc(npages
,
3501 cifs_uncached_readv_complete
);
3503 add_credits_and_wake_if(server
, credits
, 0);
3508 rc
= cifs_read_allocate_pages(rdata
, npages
);
3510 kvfree(rdata
->pages
);
3512 add_credits_and_wake_if(server
, credits
, 0);
3516 rdata
->tailsz
= PAGE_SIZE
;
3519 rdata
->cfile
= cifsFileInfo_get(open_file
);
3520 rdata
->nr_pages
= npages
;
3521 rdata
->offset
= offset
;
3522 rdata
->bytes
= cur_len
;
3524 rdata
->pagesz
= PAGE_SIZE
;
3525 rdata
->read_into_pages
= cifs_uncached_read_into_pages
;
3526 rdata
->copy_into_pages
= cifs_uncached_copy_into_pages
;
3527 rdata
->credits
= credits_on_stack
;
3529 kref_get(&ctx
->refcount
);
3531 rc
= adjust_credits(server
, &rdata
->credits
, rdata
->bytes
);
3534 if (rdata
->cfile
->invalidHandle
)
3537 rc
= server
->ops
->async_readv(rdata
);
3541 add_credits_and_wake_if(server
, &rdata
->credits
, 0);
3542 kref_put(&rdata
->refcount
,
3543 cifs_uncached_readdata_release
);
3544 if (rc
== -EAGAIN
) {
3545 iov_iter_revert(&direct_iov
, cur_len
);
3551 list_add_tail(&rdata
->list
, rdata_list
);
3560 collect_uncached_read_data(struct cifs_aio_ctx
*ctx
)
3562 struct cifs_readdata
*rdata
, *tmp
;
3563 struct iov_iter
*to
= &ctx
->iter
;
3564 struct cifs_sb_info
*cifs_sb
;
3565 struct cifs_tcon
*tcon
;
3569 tcon
= tlink_tcon(ctx
->cfile
->tlink
);
3570 cifs_sb
= CIFS_SB(ctx
->cfile
->dentry
->d_sb
);
3572 mutex_lock(&ctx
->aio_mutex
);
3574 if (list_empty(&ctx
->list
)) {
3575 mutex_unlock(&ctx
->aio_mutex
);
3580 /* the loop below should proceed in the order of increasing offsets */
3582 list_for_each_entry_safe(rdata
, tmp
, &ctx
->list
, list
) {
3584 if (!try_wait_for_completion(&rdata
->done
)) {
3585 mutex_unlock(&ctx
->aio_mutex
);
3589 if (rdata
->result
== -EAGAIN
) {
3590 /* resend call if it's a retryable error */
3591 struct list_head tmp_list
;
3592 unsigned int got_bytes
= rdata
->got_bytes
;
3594 list_del_init(&rdata
->list
);
3595 INIT_LIST_HEAD(&tmp_list
);
3598 * Got a part of data and then reconnect has
3599 * happened -- fill the buffer and continue
3602 if (got_bytes
&& got_bytes
< rdata
->bytes
) {
3604 if (!ctx
->direct_io
)
3605 rc
= cifs_readdata_to_iov(rdata
, to
);
3607 kref_put(&rdata
->refcount
,
3608 cifs_uncached_readdata_release
);
3613 if (ctx
->direct_io
) {
3615 * Re-use rdata as this is a
3618 rc
= cifs_resend_rdata(
3622 rc
= cifs_send_async_read(
3623 rdata
->offset
+ got_bytes
,
3624 rdata
->bytes
- got_bytes
,
3625 rdata
->cfile
, cifs_sb
,
3628 kref_put(&rdata
->refcount
,
3629 cifs_uncached_readdata_release
);
3632 list_splice(&tmp_list
, &ctx
->list
);
3635 } else if (rdata
->result
)
3637 else if (!ctx
->direct_io
)
3638 rc
= cifs_readdata_to_iov(rdata
, to
);
3640 /* if there was a short read -- discard anything left */
3641 if (rdata
->got_bytes
&& rdata
->got_bytes
< rdata
->bytes
)
3644 ctx
->total_len
+= rdata
->got_bytes
;
3646 list_del_init(&rdata
->list
);
3647 kref_put(&rdata
->refcount
, cifs_uncached_readdata_release
);
3650 if (!ctx
->direct_io
) {
3651 for (i
= 0; i
< ctx
->npages
; i
++) {
3652 if (ctx
->should_dirty
)
3653 set_page_dirty(ctx
->bv
[i
].bv_page
);
3654 put_page(ctx
->bv
[i
].bv_page
);
3657 ctx
->total_len
= ctx
->len
- iov_iter_count(to
);
3660 /* mask nodata case */
3664 ctx
->rc
= (rc
== 0) ? ctx
->total_len
: rc
;
3666 mutex_unlock(&ctx
->aio_mutex
);
3668 if (ctx
->iocb
&& ctx
->iocb
->ki_complete
)
3669 ctx
->iocb
->ki_complete(ctx
->iocb
, ctx
->rc
, 0);
3671 complete(&ctx
->done
);
3674 static ssize_t
__cifs_readv(
3675 struct kiocb
*iocb
, struct iov_iter
*to
, bool direct
)
3678 struct file
*file
= iocb
->ki_filp
;
3679 struct cifs_sb_info
*cifs_sb
;
3680 struct cifsFileInfo
*cfile
;
3681 struct cifs_tcon
*tcon
;
3682 ssize_t rc
, total_read
= 0;
3683 loff_t offset
= iocb
->ki_pos
;
3684 struct cifs_aio_ctx
*ctx
;
3687 * iov_iter_get_pages_alloc() doesn't work with ITER_KVEC,
3688 * fall back to data copy read path
3689 * this could be improved by getting pages directly in ITER_KVEC
3691 if (direct
&& to
->type
& ITER_KVEC
) {
3692 cifs_dbg(FYI
, "use non-direct cifs_user_readv for kvec I/O\n");
3696 len
= iov_iter_count(to
);
3700 cifs_sb
= CIFS_FILE_SB(file
);
3701 cfile
= file
->private_data
;
3702 tcon
= tlink_tcon(cfile
->tlink
);
3704 if (!tcon
->ses
->server
->ops
->async_readv
)
3707 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
3708 cifs_dbg(FYI
, "attempting read on write only file instance\n");
3710 ctx
= cifs_aio_ctx_alloc();
3714 ctx
->cfile
= cifsFileInfo_get(cfile
);
3716 if (!is_sync_kiocb(iocb
))
3719 if (iter_is_iovec(to
))
3720 ctx
->should_dirty
= true;
3724 ctx
->direct_io
= true;
3728 rc
= setup_aio_ctx_iter(ctx
, to
, READ
);
3730 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
3736 /* grab a lock here due to read response handlers can access ctx */
3737 mutex_lock(&ctx
->aio_mutex
);
3739 rc
= cifs_send_async_read(offset
, len
, cfile
, cifs_sb
, &ctx
->list
, ctx
);
3741 /* if at least one read request send succeeded, then reset rc */
3742 if (!list_empty(&ctx
->list
))
3745 mutex_unlock(&ctx
->aio_mutex
);
3748 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
3752 if (!is_sync_kiocb(iocb
)) {
3753 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
3754 return -EIOCBQUEUED
;
3757 rc
= wait_for_completion_killable(&ctx
->done
);
3759 mutex_lock(&ctx
->aio_mutex
);
3760 ctx
->rc
= rc
= -EINTR
;
3761 total_read
= ctx
->total_len
;
3762 mutex_unlock(&ctx
->aio_mutex
);
3765 total_read
= ctx
->total_len
;
3768 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
3771 iocb
->ki_pos
+= total_read
;
3777 ssize_t
cifs_direct_readv(struct kiocb
*iocb
, struct iov_iter
*to
)
3779 return __cifs_readv(iocb
, to
, true);
3782 ssize_t
cifs_user_readv(struct kiocb
*iocb
, struct iov_iter
*to
)
3784 return __cifs_readv(iocb
, to
, false);
3788 cifs_strict_readv(struct kiocb
*iocb
, struct iov_iter
*to
)
3790 struct inode
*inode
= file_inode(iocb
->ki_filp
);
3791 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
3792 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
3793 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)
3794 iocb
->ki_filp
->private_data
;
3795 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
3799 * In strict cache mode we need to read from the server all the time
3800 * if we don't have level II oplock because the server can delay mtime
3801 * change - so we can't make a decision about inode invalidating.
3802 * And we can also fail with pagereading if there are mandatory locks
3803 * on pages affected by this read but not on the region from pos to
3806 if (!CIFS_CACHE_READ(cinode
))
3807 return cifs_user_readv(iocb
, to
);
3809 if (cap_unix(tcon
->ses
) &&
3810 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
3811 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
3812 return generic_file_read_iter(iocb
, to
);
3815 * We need to hold the sem to be sure nobody modifies lock list
3816 * with a brlock that prevents reading.
3818 down_read(&cinode
->lock_sem
);
3819 if (!cifs_find_lock_conflict(cfile
, iocb
->ki_pos
, iov_iter_count(to
),
3820 tcon
->ses
->server
->vals
->shared_lock_type
,
3821 0, NULL
, CIFS_READ_OP
))
3822 rc
= generic_file_read_iter(iocb
, to
);
3823 up_read(&cinode
->lock_sem
);
3828 cifs_read(struct file
*file
, char *read_data
, size_t read_size
, loff_t
*offset
)
3831 unsigned int bytes_read
= 0;
3832 unsigned int total_read
;
3833 unsigned int current_read_size
;
3835 struct cifs_sb_info
*cifs_sb
;
3836 struct cifs_tcon
*tcon
;
3837 struct TCP_Server_Info
*server
;
3840 struct cifsFileInfo
*open_file
;
3841 struct cifs_io_parms io_parms
;
3842 int buf_type
= CIFS_NO_BUFFER
;
3846 cifs_sb
= CIFS_FILE_SB(file
);
3848 /* FIXME: set up handlers for larger reads and/or convert to async */
3849 rsize
= min_t(unsigned int, cifs_sb
->rsize
, CIFSMaxBufSize
);
3851 if (file
->private_data
== NULL
) {
3856 open_file
= file
->private_data
;
3857 tcon
= tlink_tcon(open_file
->tlink
);
3858 server
= tcon
->ses
->server
;
3860 if (!server
->ops
->sync_read
) {
3865 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
3866 pid
= open_file
->pid
;
3868 pid
= current
->tgid
;
3870 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
3871 cifs_dbg(FYI
, "attempting read on write only file instance\n");
3873 for (total_read
= 0, cur_offset
= read_data
; read_size
> total_read
;
3874 total_read
+= bytes_read
, cur_offset
+= bytes_read
) {
3876 current_read_size
= min_t(uint
, read_size
- total_read
,
3879 * For windows me and 9x we do not want to request more
3880 * than it negotiated since it will refuse the read
3883 if ((tcon
->ses
) && !(tcon
->ses
->capabilities
&
3884 tcon
->ses
->server
->vals
->cap_large_files
)) {
3885 current_read_size
= min_t(uint
,
3886 current_read_size
, CIFSMaxBufSize
);
3888 if (open_file
->invalidHandle
) {
3889 rc
= cifs_reopen_file(open_file
, true);
3894 io_parms
.tcon
= tcon
;
3895 io_parms
.offset
= *offset
;
3896 io_parms
.length
= current_read_size
;
3897 rc
= server
->ops
->sync_read(xid
, &open_file
->fid
, &io_parms
,
3898 &bytes_read
, &cur_offset
,
3900 } while (rc
== -EAGAIN
);
3902 if (rc
|| (bytes_read
== 0)) {
3910 cifs_stats_bytes_read(tcon
, total_read
);
3911 *offset
+= bytes_read
;
3919 * If the page is mmap'ed into a process' page tables, then we need to make
3920 * sure that it doesn't change while being written back.
3923 cifs_page_mkwrite(struct vm_fault
*vmf
)
3925 struct page
*page
= vmf
->page
;
3928 return VM_FAULT_LOCKED
;
3931 static const struct vm_operations_struct cifs_file_vm_ops
= {
3932 .fault
= filemap_fault
,
3933 .map_pages
= filemap_map_pages
,
3934 .page_mkwrite
= cifs_page_mkwrite
,
3937 int cifs_file_strict_mmap(struct file
*file
, struct vm_area_struct
*vma
)
3940 struct inode
*inode
= file_inode(file
);
3944 if (!CIFS_CACHE_READ(CIFS_I(inode
)))
3945 rc
= cifs_zap_mapping(inode
);
3947 rc
= generic_file_mmap(file
, vma
);
3949 vma
->vm_ops
= &cifs_file_vm_ops
;
3955 int cifs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
3961 rc
= cifs_revalidate_file(file
);
3963 cifs_dbg(FYI
, "Validation prior to mmap failed, error=%d\n",
3966 rc
= generic_file_mmap(file
, vma
);
3968 vma
->vm_ops
= &cifs_file_vm_ops
;
3975 cifs_readv_complete(struct work_struct
*work
)
3977 unsigned int i
, got_bytes
;
3978 struct cifs_readdata
*rdata
= container_of(work
,
3979 struct cifs_readdata
, work
);
3981 got_bytes
= rdata
->got_bytes
;
3982 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
3983 struct page
*page
= rdata
->pages
[i
];
3985 lru_cache_add_file(page
);
3987 if (rdata
->result
== 0 ||
3988 (rdata
->result
== -EAGAIN
&& got_bytes
)) {
3989 flush_dcache_page(page
);
3990 SetPageUptodate(page
);
3995 if (rdata
->result
== 0 ||
3996 (rdata
->result
== -EAGAIN
&& got_bytes
))
3997 cifs_readpage_to_fscache(rdata
->mapping
->host
, page
);
3999 got_bytes
-= min_t(unsigned int, PAGE_SIZE
, got_bytes
);
4002 rdata
->pages
[i
] = NULL
;
4004 kref_put(&rdata
->refcount
, cifs_readdata_release
);
4008 readpages_fill_pages(struct TCP_Server_Info
*server
,
4009 struct cifs_readdata
*rdata
, struct iov_iter
*iter
,
4016 unsigned int nr_pages
= rdata
->nr_pages
;
4017 unsigned int page_offset
= rdata
->page_offset
;
4019 /* determine the eof that the server (probably) has */
4020 eof
= CIFS_I(rdata
->mapping
->host
)->server_eof
;
4021 eof_index
= eof
? (eof
- 1) >> PAGE_SHIFT
: 0;
4022 cifs_dbg(FYI
, "eof=%llu eof_index=%lu\n", eof
, eof_index
);
4024 rdata
->got_bytes
= 0;
4025 rdata
->tailsz
= PAGE_SIZE
;
4026 for (i
= 0; i
< nr_pages
; i
++) {
4027 struct page
*page
= rdata
->pages
[i
];
4028 unsigned int to_read
= rdata
->pagesz
;
4032 to_read
-= page_offset
;
4038 if (len
>= to_read
) {
4040 } else if (len
> 0) {
4041 /* enough for partial page, fill and zero the rest */
4042 zero_user(page
, len
+ page_offset
, to_read
- len
);
4043 n
= rdata
->tailsz
= len
;
4045 } else if (page
->index
> eof_index
) {
4047 * The VFS will not try to do readahead past the
4048 * i_size, but it's possible that we have outstanding
4049 * writes with gaps in the middle and the i_size hasn't
4050 * caught up yet. Populate those with zeroed out pages
4051 * to prevent the VFS from repeatedly attempting to
4052 * fill them until the writes are flushed.
4054 zero_user(page
, 0, PAGE_SIZE
);
4055 lru_cache_add_file(page
);
4056 flush_dcache_page(page
);
4057 SetPageUptodate(page
);
4060 rdata
->pages
[i
] = NULL
;
4064 /* no need to hold page hostage */
4065 lru_cache_add_file(page
);
4068 rdata
->pages
[i
] = NULL
;
4074 result
= copy_page_from_iter(
4075 page
, page_offset
, n
, iter
);
4076 #ifdef CONFIG_CIFS_SMB_DIRECT
4081 result
= cifs_read_page_from_socket(
4082 server
, page
, page_offset
, n
);
4086 rdata
->got_bytes
+= result
;
4089 return rdata
->got_bytes
> 0 && result
!= -ECONNABORTED
?
4090 rdata
->got_bytes
: result
;
4094 cifs_readpages_read_into_pages(struct TCP_Server_Info
*server
,
4095 struct cifs_readdata
*rdata
, unsigned int len
)
4097 return readpages_fill_pages(server
, rdata
, NULL
, len
);
4101 cifs_readpages_copy_into_pages(struct TCP_Server_Info
*server
,
4102 struct cifs_readdata
*rdata
,
4103 struct iov_iter
*iter
)
4105 return readpages_fill_pages(server
, rdata
, iter
, iter
->count
);
4109 readpages_get_pages(struct address_space
*mapping
, struct list_head
*page_list
,
4110 unsigned int rsize
, struct list_head
*tmplist
,
4111 unsigned int *nr_pages
, loff_t
*offset
, unsigned int *bytes
)
4113 struct page
*page
, *tpage
;
4114 unsigned int expected_index
;
4116 gfp_t gfp
= readahead_gfp_mask(mapping
);
4118 INIT_LIST_HEAD(tmplist
);
4120 page
= lru_to_page(page_list
);
4123 * Lock the page and put it in the cache. Since no one else
4124 * should have access to this page, we're safe to simply set
4125 * PG_locked without checking it first.
4127 __SetPageLocked(page
);
4128 rc
= add_to_page_cache_locked(page
, mapping
,
4131 /* give up if we can't stick it in the cache */
4133 __ClearPageLocked(page
);
4137 /* move first page to the tmplist */
4138 *offset
= (loff_t
)page
->index
<< PAGE_SHIFT
;
4141 list_move_tail(&page
->lru
, tmplist
);
4143 /* now try and add more pages onto the request */
4144 expected_index
= page
->index
+ 1;
4145 list_for_each_entry_safe_reverse(page
, tpage
, page_list
, lru
) {
4146 /* discontinuity ? */
4147 if (page
->index
!= expected_index
)
4150 /* would this page push the read over the rsize? */
4151 if (*bytes
+ PAGE_SIZE
> rsize
)
4154 __SetPageLocked(page
);
4155 if (add_to_page_cache_locked(page
, mapping
, page
->index
, gfp
)) {
4156 __ClearPageLocked(page
);
4159 list_move_tail(&page
->lru
, tmplist
);
4160 (*bytes
) += PAGE_SIZE
;
4167 static int cifs_readpages(struct file
*file
, struct address_space
*mapping
,
4168 struct list_head
*page_list
, unsigned num_pages
)
4171 struct list_head tmplist
;
4172 struct cifsFileInfo
*open_file
= file
->private_data
;
4173 struct cifs_sb_info
*cifs_sb
= CIFS_FILE_SB(file
);
4174 struct TCP_Server_Info
*server
;
4180 * Reads as many pages as possible from fscache. Returns -ENOBUFS
4181 * immediately if the cookie is negative
4183 * After this point, every page in the list might have PG_fscache set,
4184 * so we will need to clean that up off of every page we don't use.
4186 rc
= cifs_readpages_from_fscache(mapping
->host
, mapping
, page_list
,
4193 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
4194 pid
= open_file
->pid
;
4196 pid
= current
->tgid
;
4199 server
= tlink_tcon(open_file
->tlink
)->ses
->server
;
4201 cifs_dbg(FYI
, "%s: file=%p mapping=%p num_pages=%u\n",
4202 __func__
, file
, mapping
, num_pages
);
4205 * Start with the page at end of list and move it to private
4206 * list. Do the same with any following pages until we hit
4207 * the rsize limit, hit an index discontinuity, or run out of
4208 * pages. Issue the async read and then start the loop again
4209 * until the list is empty.
4211 * Note that list order is important. The page_list is in
4212 * the order of declining indexes. When we put the pages in
4213 * the rdata->pages, then we want them in increasing order.
4215 while (!list_empty(page_list
)) {
4216 unsigned int i
, nr_pages
, bytes
, rsize
;
4218 struct page
*page
, *tpage
;
4219 struct cifs_readdata
*rdata
;
4220 struct cifs_credits credits_on_stack
;
4221 struct cifs_credits
*credits
= &credits_on_stack
;
4223 if (open_file
->invalidHandle
) {
4224 rc
= cifs_reopen_file(open_file
, true);
4231 rc
= server
->ops
->wait_mtu_credits(server
, cifs_sb
->rsize
,
4237 * Give up immediately if rsize is too small to read an entire
4238 * page. The VFS will fall back to readpage. We should never
4239 * reach this point however since we set ra_pages to 0 when the
4240 * rsize is smaller than a cache page.
4242 if (unlikely(rsize
< PAGE_SIZE
)) {
4243 add_credits_and_wake_if(server
, credits
, 0);
4248 rc
= readpages_get_pages(mapping
, page_list
, rsize
, &tmplist
,
4249 &nr_pages
, &offset
, &bytes
);
4251 add_credits_and_wake_if(server
, credits
, 0);
4255 rdata
= cifs_readdata_alloc(nr_pages
, cifs_readv_complete
);
4257 /* best to give up if we're out of mem */
4258 list_for_each_entry_safe(page
, tpage
, &tmplist
, lru
) {
4259 list_del(&page
->lru
);
4260 lru_cache_add_file(page
);
4265 add_credits_and_wake_if(server
, credits
, 0);
4269 rdata
->cfile
= cifsFileInfo_get(open_file
);
4270 rdata
->mapping
= mapping
;
4271 rdata
->offset
= offset
;
4272 rdata
->bytes
= bytes
;
4274 rdata
->pagesz
= PAGE_SIZE
;
4275 rdata
->tailsz
= PAGE_SIZE
;
4276 rdata
->read_into_pages
= cifs_readpages_read_into_pages
;
4277 rdata
->copy_into_pages
= cifs_readpages_copy_into_pages
;
4278 rdata
->credits
= credits_on_stack
;
4280 list_for_each_entry_safe(page
, tpage
, &tmplist
, lru
) {
4281 list_del(&page
->lru
);
4282 rdata
->pages
[rdata
->nr_pages
++] = page
;
4285 rc
= adjust_credits(server
, &rdata
->credits
, rdata
->bytes
);
4288 if (rdata
->cfile
->invalidHandle
)
4291 rc
= server
->ops
->async_readv(rdata
);
4295 add_credits_and_wake_if(server
, &rdata
->credits
, 0);
4296 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
4297 page
= rdata
->pages
[i
];
4298 lru_cache_add_file(page
);
4302 /* Fallback to the readpage in error/reconnect cases */
4303 kref_put(&rdata
->refcount
, cifs_readdata_release
);
4307 kref_put(&rdata
->refcount
, cifs_readdata_release
);
4310 /* Any pages that have been shown to fscache but didn't get added to
4311 * the pagecache must be uncached before they get returned to the
4314 cifs_fscache_readpages_cancel(mapping
->host
, page_list
);
4320 * cifs_readpage_worker must be called with the page pinned
4322 static int cifs_readpage_worker(struct file
*file
, struct page
*page
,
4328 /* Is the page cached? */
4329 rc
= cifs_readpage_from_fscache(file_inode(file
), page
);
4333 read_data
= kmap(page
);
4334 /* for reads over a certain size could initiate async read ahead */
4336 rc
= cifs_read(file
, read_data
, PAGE_SIZE
, poffset
);
4341 cifs_dbg(FYI
, "Bytes read %d\n", rc
);
4343 /* we do not want atime to be less than mtime, it broke some apps */
4344 file_inode(file
)->i_atime
= current_time(file_inode(file
));
4345 if (timespec64_compare(&(file_inode(file
)->i_atime
), &(file_inode(file
)->i_mtime
)))
4346 file_inode(file
)->i_atime
= file_inode(file
)->i_mtime
;
4348 file_inode(file
)->i_atime
= current_time(file_inode(file
));
4351 memset(read_data
+ rc
, 0, PAGE_SIZE
- rc
);
4353 flush_dcache_page(page
);
4354 SetPageUptodate(page
);
4356 /* send this page to the cache */
4357 cifs_readpage_to_fscache(file_inode(file
), page
);
4369 static int cifs_readpage(struct file
*file
, struct page
*page
)
4371 loff_t offset
= (loff_t
)page
->index
<< PAGE_SHIFT
;
4377 if (file
->private_data
== NULL
) {
4383 cifs_dbg(FYI
, "readpage %p at offset %d 0x%x\n",
4384 page
, (int)offset
, (int)offset
);
4386 rc
= cifs_readpage_worker(file
, page
, &offset
);
4392 static int is_inode_writable(struct cifsInodeInfo
*cifs_inode
)
4394 struct cifsFileInfo
*open_file
;
4395 struct cifs_tcon
*tcon
=
4396 cifs_sb_master_tcon(CIFS_SB(cifs_inode
->vfs_inode
.i_sb
));
4398 spin_lock(&tcon
->open_file_lock
);
4399 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
4400 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_WRITE
) {
4401 spin_unlock(&tcon
->open_file_lock
);
4405 spin_unlock(&tcon
->open_file_lock
);
4409 /* We do not want to update the file size from server for inodes
4410 open for write - to avoid races with writepage extending
4411 the file - in the future we could consider allowing
4412 refreshing the inode only on increases in the file size
4413 but this is tricky to do without racing with writebehind
4414 page caching in the current Linux kernel design */
4415 bool is_size_safe_to_change(struct cifsInodeInfo
*cifsInode
, __u64 end_of_file
)
4420 if (is_inode_writable(cifsInode
)) {
4421 /* This inode is open for write at least once */
4422 struct cifs_sb_info
*cifs_sb
;
4424 cifs_sb
= CIFS_SB(cifsInode
->vfs_inode
.i_sb
);
4425 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
4426 /* since no page cache to corrupt on directio
4427 we can change size safely */
4431 if (i_size_read(&cifsInode
->vfs_inode
) < end_of_file
)
4439 static int cifs_write_begin(struct file
*file
, struct address_space
*mapping
,
4440 loff_t pos
, unsigned len
, unsigned flags
,
4441 struct page
**pagep
, void **fsdata
)
4444 pgoff_t index
= pos
>> PAGE_SHIFT
;
4445 loff_t offset
= pos
& (PAGE_SIZE
- 1);
4446 loff_t page_start
= pos
& PAGE_MASK
;
4451 cifs_dbg(FYI
, "write_begin from %lld len %d\n", (long long)pos
, len
);
4454 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
4460 if (PageUptodate(page
))
4464 * If we write a full page it will be up to date, no need to read from
4465 * the server. If the write is short, we'll end up doing a sync write
4468 if (len
== PAGE_SIZE
)
4472 * optimize away the read when we have an oplock, and we're not
4473 * expecting to use any of the data we'd be reading in. That
4474 * is, when the page lies beyond the EOF, or straddles the EOF
4475 * and the write will cover all of the existing data.
4477 if (CIFS_CACHE_READ(CIFS_I(mapping
->host
))) {
4478 i_size
= i_size_read(mapping
->host
);
4479 if (page_start
>= i_size
||
4480 (offset
== 0 && (pos
+ len
) >= i_size
)) {
4481 zero_user_segments(page
, 0, offset
,
4485 * PageChecked means that the parts of the page
4486 * to which we're not writing are considered up
4487 * to date. Once the data is copied to the
4488 * page, it can be set uptodate.
4490 SetPageChecked(page
);
4495 if ((file
->f_flags
& O_ACCMODE
) != O_WRONLY
&& !oncethru
) {
4497 * might as well read a page, it is fast enough. If we get
4498 * an error, we don't need to return it. cifs_write_end will
4499 * do a sync write instead since PG_uptodate isn't set.
4501 cifs_readpage_worker(file
, page
, &page_start
);
4506 /* we could try using another file handle if there is one -
4507 but how would we lock it to prevent close of that handle
4508 racing with this read? In any case
4509 this will be written out by write_end so is fine */
4516 static int cifs_release_page(struct page
*page
, gfp_t gfp
)
4518 if (PagePrivate(page
))
4521 return cifs_fscache_release_page(page
, gfp
);
4524 static void cifs_invalidate_page(struct page
*page
, unsigned int offset
,
4525 unsigned int length
)
4527 struct cifsInodeInfo
*cifsi
= CIFS_I(page
->mapping
->host
);
4529 if (offset
== 0 && length
== PAGE_SIZE
)
4530 cifs_fscache_invalidate_page(page
, &cifsi
->vfs_inode
);
4533 static int cifs_launder_page(struct page
*page
)
4536 loff_t range_start
= page_offset(page
);
4537 loff_t range_end
= range_start
+ (loff_t
)(PAGE_SIZE
- 1);
4538 struct writeback_control wbc
= {
4539 .sync_mode
= WB_SYNC_ALL
,
4541 .range_start
= range_start
,
4542 .range_end
= range_end
,
4545 cifs_dbg(FYI
, "Launder page: %p\n", page
);
4547 if (clear_page_dirty_for_io(page
))
4548 rc
= cifs_writepage_locked(page
, &wbc
);
4550 cifs_fscache_invalidate_page(page
, page
->mapping
->host
);
4554 void cifs_oplock_break(struct work_struct
*work
)
4556 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
4558 struct inode
*inode
= d_inode(cfile
->dentry
);
4559 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
4560 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
4561 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
4564 wait_on_bit(&cinode
->flags
, CIFS_INODE_PENDING_WRITERS
,
4565 TASK_UNINTERRUPTIBLE
);
4567 server
->ops
->downgrade_oplock(server
, cinode
,
4568 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2
, &cinode
->flags
));
4570 if (!CIFS_CACHE_WRITE(cinode
) && CIFS_CACHE_READ(cinode
) &&
4571 cifs_has_mand_locks(cinode
)) {
4572 cifs_dbg(FYI
, "Reset oplock to None for inode=%p due to mand locks\n",
4577 if (inode
&& S_ISREG(inode
->i_mode
)) {
4578 if (CIFS_CACHE_READ(cinode
))
4579 break_lease(inode
, O_RDONLY
);
4581 break_lease(inode
, O_WRONLY
);
4582 rc
= filemap_fdatawrite(inode
->i_mapping
);
4583 if (!CIFS_CACHE_READ(cinode
)) {
4584 rc
= filemap_fdatawait(inode
->i_mapping
);
4585 mapping_set_error(inode
->i_mapping
, rc
);
4586 cifs_zap_mapping(inode
);
4588 cifs_dbg(FYI
, "Oplock flush inode %p rc %d\n", inode
, rc
);
4591 rc
= cifs_push_locks(cfile
);
4593 cifs_dbg(VFS
, "Push locks rc = %d\n", rc
);
4596 * releasing stale oplock after recent reconnect of smb session using
4597 * a now incorrect file handle is not a data integrity issue but do
4598 * not bother sending an oplock release if session to server still is
4599 * disconnected since oplock already released by the server
4601 if (!cfile
->oplock_break_cancelled
) {
4602 rc
= tcon
->ses
->server
->ops
->oplock_response(tcon
, &cfile
->fid
,
4604 cifs_dbg(FYI
, "Oplock release rc = %d\n", rc
);
4606 cifs_done_oplock_break(cinode
);
4610 * The presence of cifs_direct_io() in the address space ops vector
4611 * allowes open() O_DIRECT flags which would have failed otherwise.
4613 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
4614 * so this method should never be called.
4616 * Direct IO is not yet supported in the cached mode.
4619 cifs_direct_io(struct kiocb
*iocb
, struct iov_iter
*iter
)
4623 * Eventually need to support direct IO for non forcedirectio mounts
4629 const struct address_space_operations cifs_addr_ops
= {
4630 .readpage
= cifs_readpage
,
4631 .readpages
= cifs_readpages
,
4632 .writepage
= cifs_writepage
,
4633 .writepages
= cifs_writepages
,
4634 .write_begin
= cifs_write_begin
,
4635 .write_end
= cifs_write_end
,
4636 .set_page_dirty
= __set_page_dirty_nobuffers
,
4637 .releasepage
= cifs_release_page
,
4638 .direct_IO
= cifs_direct_io
,
4639 .invalidatepage
= cifs_invalidate_page
,
4640 .launder_page
= cifs_launder_page
,
4644 * cifs_readpages requires the server to support a buffer large enough to
4645 * contain the header plus one complete page of data. Otherwise, we need
4646 * to leave cifs_readpages out of the address space operations.
4648 const struct address_space_operations cifs_addr_ops_smallbuf
= {
4649 .readpage
= cifs_readpage
,
4650 .writepage
= cifs_writepage
,
4651 .writepages
= cifs_writepages
,
4652 .write_begin
= cifs_write_begin
,
4653 .write_end
= cifs_write_end
,
4654 .set_page_dirty
= __set_page_dirty_nobuffers
,
4655 .releasepage
= cifs_release_page
,
4656 .invalidatepage
= cifs_invalidate_page
,
4657 .launder_page
= cifs_launder_page
,