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
&& !rc
)
1649 rc
= locks_lock_file_wait(file
, flock
);
1653 int cifs_lock(struct file
*file
, int cmd
, struct file_lock
*flock
)
1656 int lock
= 0, unlock
= 0;
1657 bool wait_flag
= false;
1658 bool posix_lck
= false;
1659 struct cifs_sb_info
*cifs_sb
;
1660 struct cifs_tcon
*tcon
;
1661 struct cifsInodeInfo
*cinode
;
1662 struct cifsFileInfo
*cfile
;
1669 cifs_dbg(FYI
, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1670 cmd
, flock
->fl_flags
, flock
->fl_type
,
1671 flock
->fl_start
, flock
->fl_end
);
1673 cfile
= (struct cifsFileInfo
*)file
->private_data
;
1674 tcon
= tlink_tcon(cfile
->tlink
);
1676 cifs_read_flock(flock
, &type
, &lock
, &unlock
, &wait_flag
,
1678 cifs_sb
= CIFS_FILE_SB(file
);
1679 netfid
= cfile
->fid
.netfid
;
1680 cinode
= CIFS_I(file_inode(file
));
1682 if (cap_unix(tcon
->ses
) &&
1683 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
1684 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
1687 * BB add code here to normalize offset and length to account for
1688 * negative length which we can not accept over the wire.
1690 if (IS_GETLK(cmd
)) {
1691 rc
= cifs_getlk(file
, flock
, type
, wait_flag
, posix_lck
, xid
);
1696 if (!lock
&& !unlock
) {
1698 * if no lock or unlock then nothing to do since we do not
1705 rc
= cifs_setlk(file
, flock
, type
, wait_flag
, posix_lck
, lock
, unlock
,
1712 * update the file size (if needed) after a write. Should be called with
1713 * the inode->i_lock held
1716 cifs_update_eof(struct cifsInodeInfo
*cifsi
, loff_t offset
,
1717 unsigned int bytes_written
)
1719 loff_t end_of_write
= offset
+ bytes_written
;
1721 if (end_of_write
> cifsi
->server_eof
)
1722 cifsi
->server_eof
= end_of_write
;
1726 cifs_write(struct cifsFileInfo
*open_file
, __u32 pid
, const char *write_data
,
1727 size_t write_size
, loff_t
*offset
)
1730 unsigned int bytes_written
= 0;
1731 unsigned int total_written
;
1732 struct cifs_sb_info
*cifs_sb
;
1733 struct cifs_tcon
*tcon
;
1734 struct TCP_Server_Info
*server
;
1736 struct dentry
*dentry
= open_file
->dentry
;
1737 struct cifsInodeInfo
*cifsi
= CIFS_I(d_inode(dentry
));
1738 struct cifs_io_parms io_parms
;
1740 cifs_sb
= CIFS_SB(dentry
->d_sb
);
1742 cifs_dbg(FYI
, "write %zd bytes to offset %lld of %pd\n",
1743 write_size
, *offset
, dentry
);
1745 tcon
= tlink_tcon(open_file
->tlink
);
1746 server
= tcon
->ses
->server
;
1748 if (!server
->ops
->sync_write
)
1753 for (total_written
= 0; write_size
> total_written
;
1754 total_written
+= bytes_written
) {
1756 while (rc
== -EAGAIN
) {
1760 if (open_file
->invalidHandle
) {
1761 /* we could deadlock if we called
1762 filemap_fdatawait from here so tell
1763 reopen_file not to flush data to
1765 rc
= cifs_reopen_file(open_file
, false);
1770 len
= min(server
->ops
->wp_retry_size(d_inode(dentry
)),
1771 (unsigned int)write_size
- total_written
);
1772 /* iov[0] is reserved for smb header */
1773 iov
[1].iov_base
= (char *)write_data
+ total_written
;
1774 iov
[1].iov_len
= len
;
1776 io_parms
.tcon
= tcon
;
1777 io_parms
.offset
= *offset
;
1778 io_parms
.length
= len
;
1779 rc
= server
->ops
->sync_write(xid
, &open_file
->fid
,
1780 &io_parms
, &bytes_written
, iov
, 1);
1782 if (rc
|| (bytes_written
== 0)) {
1790 spin_lock(&d_inode(dentry
)->i_lock
);
1791 cifs_update_eof(cifsi
, *offset
, bytes_written
);
1792 spin_unlock(&d_inode(dentry
)->i_lock
);
1793 *offset
+= bytes_written
;
1797 cifs_stats_bytes_written(tcon
, total_written
);
1799 if (total_written
> 0) {
1800 spin_lock(&d_inode(dentry
)->i_lock
);
1801 if (*offset
> d_inode(dentry
)->i_size
)
1802 i_size_write(d_inode(dentry
), *offset
);
1803 spin_unlock(&d_inode(dentry
)->i_lock
);
1805 mark_inode_dirty_sync(d_inode(dentry
));
1807 return total_written
;
1810 struct cifsFileInfo
*find_readable_file(struct cifsInodeInfo
*cifs_inode
,
1813 struct cifsFileInfo
*open_file
= NULL
;
1814 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1815 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
1817 /* only filter by fsuid on multiuser mounts */
1818 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1821 spin_lock(&tcon
->open_file_lock
);
1822 /* we could simply get the first_list_entry since write-only entries
1823 are always at the end of the list but since the first entry might
1824 have a close pending, we go through the whole list */
1825 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1826 if (fsuid_only
&& !uid_eq(open_file
->uid
, current_fsuid()))
1828 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_READ
) {
1829 if (!open_file
->invalidHandle
) {
1830 /* found a good file */
1831 /* lock it so it will not be closed on us */
1832 cifsFileInfo_get(open_file
);
1833 spin_unlock(&tcon
->open_file_lock
);
1835 } /* else might as well continue, and look for
1836 another, or simply have the caller reopen it
1837 again rather than trying to fix this handle */
1838 } else /* write only file */
1839 break; /* write only files are last so must be done */
1841 spin_unlock(&tcon
->open_file_lock
);
1845 /* Return -EBADF if no handle is found and general rc otherwise */
1847 cifs_get_writable_file(struct cifsInodeInfo
*cifs_inode
, bool fsuid_only
,
1848 struct cifsFileInfo
**ret_file
)
1850 struct cifsFileInfo
*open_file
, *inv_file
= NULL
;
1851 struct cifs_sb_info
*cifs_sb
;
1852 struct cifs_tcon
*tcon
;
1853 bool any_available
= false;
1855 unsigned int refind
= 0;
1860 * Having a null inode here (because mapping->host was set to zero by
1861 * the VFS or MM) should not happen but we had reports of on oops (due
1862 * to it being zero) during stress testcases so we need to check for it
1865 if (cifs_inode
== NULL
) {
1866 cifs_dbg(VFS
, "Null inode passed to cifs_writeable_file\n");
1871 cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1872 tcon
= cifs_sb_master_tcon(cifs_sb
);
1874 /* only filter by fsuid on multiuser mounts */
1875 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1878 spin_lock(&tcon
->open_file_lock
);
1880 if (refind
> MAX_REOPEN_ATT
) {
1881 spin_unlock(&tcon
->open_file_lock
);
1884 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1885 if (!any_available
&& open_file
->pid
!= current
->tgid
)
1887 if (fsuid_only
&& !uid_eq(open_file
->uid
, current_fsuid()))
1889 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_WRITE
) {
1890 if (!open_file
->invalidHandle
) {
1891 /* found a good writable file */
1892 cifsFileInfo_get(open_file
);
1893 spin_unlock(&tcon
->open_file_lock
);
1894 *ret_file
= open_file
;
1898 inv_file
= open_file
;
1902 /* couldn't find useable FH with same pid, try any available */
1903 if (!any_available
) {
1904 any_available
= true;
1905 goto refind_writable
;
1909 any_available
= false;
1910 cifsFileInfo_get(inv_file
);
1913 spin_unlock(&tcon
->open_file_lock
);
1916 rc
= cifs_reopen_file(inv_file
, false);
1918 *ret_file
= inv_file
;
1922 spin_lock(&tcon
->open_file_lock
);
1923 list_move_tail(&inv_file
->flist
, &cifs_inode
->openFileList
);
1924 spin_unlock(&tcon
->open_file_lock
);
1925 cifsFileInfo_put(inv_file
);
1928 spin_lock(&tcon
->open_file_lock
);
1929 goto refind_writable
;
1935 struct cifsFileInfo
*
1936 find_writable_file(struct cifsInodeInfo
*cifs_inode
, bool fsuid_only
)
1938 struct cifsFileInfo
*cfile
;
1941 rc
= cifs_get_writable_file(cifs_inode
, fsuid_only
, &cfile
);
1943 cifs_dbg(FYI
, "couldn't find writable handle rc=%d", rc
);
1948 static int cifs_partialpagewrite(struct page
*page
, unsigned from
, unsigned to
)
1950 struct address_space
*mapping
= page
->mapping
;
1951 loff_t offset
= (loff_t
)page
->index
<< PAGE_SHIFT
;
1954 int bytes_written
= 0;
1955 struct inode
*inode
;
1956 struct cifsFileInfo
*open_file
;
1958 if (!mapping
|| !mapping
->host
)
1961 inode
= page
->mapping
->host
;
1963 offset
+= (loff_t
)from
;
1964 write_data
= kmap(page
);
1967 if ((to
> PAGE_SIZE
) || (from
> to
)) {
1972 /* racing with truncate? */
1973 if (offset
> mapping
->host
->i_size
) {
1975 return 0; /* don't care */
1978 /* check to make sure that we are not extending the file */
1979 if (mapping
->host
->i_size
- offset
< (loff_t
)to
)
1980 to
= (unsigned)(mapping
->host
->i_size
- offset
);
1982 rc
= cifs_get_writable_file(CIFS_I(mapping
->host
), false, &open_file
);
1984 bytes_written
= cifs_write(open_file
, open_file
->pid
,
1985 write_data
, to
- from
, &offset
);
1986 cifsFileInfo_put(open_file
);
1987 /* Does mm or vfs already set times? */
1988 inode
->i_atime
= inode
->i_mtime
= current_time(inode
);
1989 if ((bytes_written
> 0) && (offset
))
1991 else if (bytes_written
< 0)
1996 cifs_dbg(FYI
, "No writable handle for write page rc=%d\n", rc
);
1997 if (!is_retryable_error(rc
))
2005 static struct cifs_writedata
*
2006 wdata_alloc_and_fillpages(pgoff_t tofind
, struct address_space
*mapping
,
2007 pgoff_t end
, pgoff_t
*index
,
2008 unsigned int *found_pages
)
2010 struct cifs_writedata
*wdata
;
2012 wdata
= cifs_writedata_alloc((unsigned int)tofind
,
2013 cifs_writev_complete
);
2017 *found_pages
= find_get_pages_range_tag(mapping
, index
, end
,
2018 PAGECACHE_TAG_DIRTY
, tofind
, wdata
->pages
);
2023 wdata_prepare_pages(struct cifs_writedata
*wdata
, unsigned int found_pages
,
2024 struct address_space
*mapping
,
2025 struct writeback_control
*wbc
,
2026 pgoff_t end
, pgoff_t
*index
, pgoff_t
*next
, bool *done
)
2028 unsigned int nr_pages
= 0, i
;
2031 for (i
= 0; i
< found_pages
; i
++) {
2032 page
= wdata
->pages
[i
];
2034 * At this point we hold neither the i_pages lock nor the
2035 * page lock: the page may be truncated or invalidated
2036 * (changing page->mapping to NULL), or even swizzled
2037 * back from swapper_space to tmpfs file mapping
2042 else if (!trylock_page(page
))
2045 if (unlikely(page
->mapping
!= mapping
)) {
2050 if (!wbc
->range_cyclic
&& page
->index
> end
) {
2056 if (*next
&& (page
->index
!= *next
)) {
2057 /* Not next consecutive page */
2062 if (wbc
->sync_mode
!= WB_SYNC_NONE
)
2063 wait_on_page_writeback(page
);
2065 if (PageWriteback(page
) ||
2066 !clear_page_dirty_for_io(page
)) {
2072 * This actually clears the dirty bit in the radix tree.
2073 * See cifs_writepage() for more commentary.
2075 set_page_writeback(page
);
2076 if (page_offset(page
) >= i_size_read(mapping
->host
)) {
2079 end_page_writeback(page
);
2083 wdata
->pages
[i
] = page
;
2084 *next
= page
->index
+ 1;
2088 /* reset index to refind any pages skipped */
2090 *index
= wdata
->pages
[0]->index
+ 1;
2092 /* put any pages we aren't going to use */
2093 for (i
= nr_pages
; i
< found_pages
; i
++) {
2094 put_page(wdata
->pages
[i
]);
2095 wdata
->pages
[i
] = NULL
;
2102 wdata_send_pages(struct cifs_writedata
*wdata
, unsigned int nr_pages
,
2103 struct address_space
*mapping
, struct writeback_control
*wbc
)
2106 struct TCP_Server_Info
*server
=
2107 tlink_tcon(wdata
->cfile
->tlink
)->ses
->server
;
2109 wdata
->sync_mode
= wbc
->sync_mode
;
2110 wdata
->nr_pages
= nr_pages
;
2111 wdata
->offset
= page_offset(wdata
->pages
[0]);
2112 wdata
->pagesz
= PAGE_SIZE
;
2113 wdata
->tailsz
= min(i_size_read(mapping
->host
) -
2114 page_offset(wdata
->pages
[nr_pages
- 1]),
2116 wdata
->bytes
= ((nr_pages
- 1) * PAGE_SIZE
) + wdata
->tailsz
;
2117 wdata
->pid
= wdata
->cfile
->pid
;
2119 rc
= adjust_credits(server
, &wdata
->credits
, wdata
->bytes
);
2123 if (wdata
->cfile
->invalidHandle
)
2126 rc
= server
->ops
->async_writev(wdata
, cifs_writedata_release
);
2131 static int cifs_writepages(struct address_space
*mapping
,
2132 struct writeback_control
*wbc
)
2134 struct inode
*inode
= mapping
->host
;
2135 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2136 struct TCP_Server_Info
*server
;
2137 bool done
= false, scanned
= false, range_whole
= false;
2139 struct cifs_writedata
*wdata
;
2140 struct cifsFileInfo
*cfile
= NULL
;
2146 * If wsize is smaller than the page cache size, default to writing
2147 * one page at a time via cifs_writepage
2149 if (cifs_sb
->wsize
< PAGE_SIZE
)
2150 return generic_writepages(mapping
, wbc
);
2153 if (wbc
->range_cyclic
) {
2154 index
= mapping
->writeback_index
; /* Start from prev offset */
2157 index
= wbc
->range_start
>> PAGE_SHIFT
;
2158 end
= wbc
->range_end
>> PAGE_SHIFT
;
2159 if (wbc
->range_start
== 0 && wbc
->range_end
== LLONG_MAX
)
2163 server
= cifs_sb_master_tcon(cifs_sb
)->ses
->server
;
2165 while (!done
&& index
<= end
) {
2166 unsigned int i
, nr_pages
, found_pages
, wsize
;
2167 pgoff_t next
= 0, tofind
, saved_index
= index
;
2168 struct cifs_credits credits_on_stack
;
2169 struct cifs_credits
*credits
= &credits_on_stack
;
2170 int get_file_rc
= 0;
2173 cifsFileInfo_put(cfile
);
2175 rc
= cifs_get_writable_file(CIFS_I(inode
), false, &cfile
);
2177 /* in case of an error store it to return later */
2181 rc
= server
->ops
->wait_mtu_credits(server
, cifs_sb
->wsize
,
2188 tofind
= min((wsize
/ PAGE_SIZE
) - 1, end
- index
) + 1;
2190 wdata
= wdata_alloc_and_fillpages(tofind
, mapping
, end
, &index
,
2195 add_credits_and_wake_if(server
, credits
, 0);
2199 if (found_pages
== 0) {
2200 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2201 add_credits_and_wake_if(server
, credits
, 0);
2205 nr_pages
= wdata_prepare_pages(wdata
, found_pages
, mapping
, wbc
,
2206 end
, &index
, &next
, &done
);
2208 /* nothing to write? */
2209 if (nr_pages
== 0) {
2210 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2211 add_credits_and_wake_if(server
, credits
, 0);
2215 wdata
->credits
= credits_on_stack
;
2216 wdata
->cfile
= cfile
;
2219 if (!wdata
->cfile
) {
2220 cifs_dbg(VFS
, "No writable handle in writepages rc=%d\n",
2222 if (is_retryable_error(get_file_rc
))
2227 rc
= wdata_send_pages(wdata
, nr_pages
, mapping
, wbc
);
2229 for (i
= 0; i
< nr_pages
; ++i
)
2230 unlock_page(wdata
->pages
[i
]);
2232 /* send failure -- clean up the mess */
2234 add_credits_and_wake_if(server
, &wdata
->credits
, 0);
2235 for (i
= 0; i
< nr_pages
; ++i
) {
2236 if (is_retryable_error(rc
))
2237 redirty_page_for_writepage(wbc
,
2240 SetPageError(wdata
->pages
[i
]);
2241 end_page_writeback(wdata
->pages
[i
]);
2242 put_page(wdata
->pages
[i
]);
2244 if (!is_retryable_error(rc
))
2245 mapping_set_error(mapping
, rc
);
2247 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2249 if (wbc
->sync_mode
== WB_SYNC_ALL
&& rc
== -EAGAIN
) {
2250 index
= saved_index
;
2254 /* Return immediately if we received a signal during writing */
2255 if (is_interrupt_error(rc
)) {
2260 if (rc
!= 0 && saved_rc
== 0)
2263 wbc
->nr_to_write
-= nr_pages
;
2264 if (wbc
->nr_to_write
<= 0)
2270 if (!scanned
&& !done
) {
2272 * We hit the last page and there is more work to be done: wrap
2273 * back to the start of the file
2283 if (wbc
->range_cyclic
|| (range_whole
&& wbc
->nr_to_write
> 0))
2284 mapping
->writeback_index
= index
;
2287 cifsFileInfo_put(cfile
);
2293 cifs_writepage_locked(struct page
*page
, struct writeback_control
*wbc
)
2299 /* BB add check for wbc flags */
2301 if (!PageUptodate(page
))
2302 cifs_dbg(FYI
, "ppw - page not up to date\n");
2305 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2307 * A writepage() implementation always needs to do either this,
2308 * or re-dirty the page with "redirty_page_for_writepage()" in
2309 * the case of a failure.
2311 * Just unlocking the page will cause the radix tree tag-bits
2312 * to fail to update with the state of the page correctly.
2314 set_page_writeback(page
);
2316 rc
= cifs_partialpagewrite(page
, 0, PAGE_SIZE
);
2317 if (is_retryable_error(rc
)) {
2318 if (wbc
->sync_mode
== WB_SYNC_ALL
&& rc
== -EAGAIN
)
2320 redirty_page_for_writepage(wbc
, page
);
2321 } else if (rc
!= 0) {
2323 mapping_set_error(page
->mapping
, rc
);
2325 SetPageUptodate(page
);
2327 end_page_writeback(page
);
2333 static int cifs_writepage(struct page
*page
, struct writeback_control
*wbc
)
2335 int rc
= cifs_writepage_locked(page
, wbc
);
2340 static int cifs_write_end(struct file
*file
, struct address_space
*mapping
,
2341 loff_t pos
, unsigned len
, unsigned copied
,
2342 struct page
*page
, void *fsdata
)
2345 struct inode
*inode
= mapping
->host
;
2346 struct cifsFileInfo
*cfile
= file
->private_data
;
2347 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->dentry
->d_sb
);
2350 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
2353 pid
= current
->tgid
;
2355 cifs_dbg(FYI
, "write_end for page %p from pos %lld with %d bytes\n",
2358 if (PageChecked(page
)) {
2360 SetPageUptodate(page
);
2361 ClearPageChecked(page
);
2362 } else if (!PageUptodate(page
) && copied
== PAGE_SIZE
)
2363 SetPageUptodate(page
);
2365 if (!PageUptodate(page
)) {
2367 unsigned offset
= pos
& (PAGE_SIZE
- 1);
2371 /* this is probably better than directly calling
2372 partialpage_write since in this function the file handle is
2373 known which we might as well leverage */
2374 /* BB check if anything else missing out of ppw
2375 such as updating last write time */
2376 page_data
= kmap(page
);
2377 rc
= cifs_write(cfile
, pid
, page_data
+ offset
, copied
, &pos
);
2378 /* if (rc < 0) should we set writebehind rc? */
2385 set_page_dirty(page
);
2389 spin_lock(&inode
->i_lock
);
2390 if (pos
> inode
->i_size
)
2391 i_size_write(inode
, pos
);
2392 spin_unlock(&inode
->i_lock
);
2401 int cifs_strict_fsync(struct file
*file
, loff_t start
, loff_t end
,
2406 struct cifs_tcon
*tcon
;
2407 struct TCP_Server_Info
*server
;
2408 struct cifsFileInfo
*smbfile
= file
->private_data
;
2409 struct inode
*inode
= file_inode(file
);
2410 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2412 rc
= file_write_and_wait_range(file
, start
, end
);
2419 cifs_dbg(FYI
, "Sync file - name: %pD datasync: 0x%x\n",
2422 if (!CIFS_CACHE_READ(CIFS_I(inode
))) {
2423 rc
= cifs_zap_mapping(inode
);
2425 cifs_dbg(FYI
, "rc: %d during invalidate phase\n", rc
);
2426 rc
= 0; /* don't care about it in fsync */
2430 tcon
= tlink_tcon(smbfile
->tlink
);
2431 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
)) {
2432 server
= tcon
->ses
->server
;
2433 if (server
->ops
->flush
)
2434 rc
= server
->ops
->flush(xid
, tcon
, &smbfile
->fid
);
2440 inode_unlock(inode
);
2444 int cifs_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
2448 struct cifs_tcon
*tcon
;
2449 struct TCP_Server_Info
*server
;
2450 struct cifsFileInfo
*smbfile
= file
->private_data
;
2451 struct cifs_sb_info
*cifs_sb
= CIFS_FILE_SB(file
);
2452 struct inode
*inode
= file
->f_mapping
->host
;
2454 rc
= file_write_and_wait_range(file
, start
, end
);
2461 cifs_dbg(FYI
, "Sync file - name: %pD datasync: 0x%x\n",
2464 tcon
= tlink_tcon(smbfile
->tlink
);
2465 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
)) {
2466 server
= tcon
->ses
->server
;
2467 if (server
->ops
->flush
)
2468 rc
= server
->ops
->flush(xid
, tcon
, &smbfile
->fid
);
2474 inode_unlock(inode
);
2479 * As file closes, flush all cached write data for this inode checking
2480 * for write behind errors.
2482 int cifs_flush(struct file
*file
, fl_owner_t id
)
2484 struct inode
*inode
= file_inode(file
);
2487 if (file
->f_mode
& FMODE_WRITE
)
2488 rc
= filemap_write_and_wait(inode
->i_mapping
);
2490 cifs_dbg(FYI
, "Flush inode %p file %p rc %d\n", inode
, file
, rc
);
2496 cifs_write_allocate_pages(struct page
**pages
, unsigned long num_pages
)
2501 for (i
= 0; i
< num_pages
; i
++) {
2502 pages
[i
] = alloc_page(GFP_KERNEL
|__GFP_HIGHMEM
);
2505 * save number of pages we have already allocated and
2506 * return with ENOMEM error
2515 for (i
= 0; i
< num_pages
; i
++)
2522 size_t get_numpages(const size_t wsize
, const size_t len
, size_t *cur_len
)
2527 clen
= min_t(const size_t, len
, wsize
);
2528 num_pages
= DIV_ROUND_UP(clen
, PAGE_SIZE
);
2537 cifs_uncached_writedata_release(struct kref
*refcount
)
2540 struct cifs_writedata
*wdata
= container_of(refcount
,
2541 struct cifs_writedata
, refcount
);
2543 kref_put(&wdata
->ctx
->refcount
, cifs_aio_ctx_release
);
2544 for (i
= 0; i
< wdata
->nr_pages
; i
++)
2545 put_page(wdata
->pages
[i
]);
2546 cifs_writedata_release(refcount
);
2549 static void collect_uncached_write_data(struct cifs_aio_ctx
*ctx
);
2552 cifs_uncached_writev_complete(struct work_struct
*work
)
2554 struct cifs_writedata
*wdata
= container_of(work
,
2555 struct cifs_writedata
, work
);
2556 struct inode
*inode
= d_inode(wdata
->cfile
->dentry
);
2557 struct cifsInodeInfo
*cifsi
= CIFS_I(inode
);
2559 spin_lock(&inode
->i_lock
);
2560 cifs_update_eof(cifsi
, wdata
->offset
, wdata
->bytes
);
2561 if (cifsi
->server_eof
> inode
->i_size
)
2562 i_size_write(inode
, cifsi
->server_eof
);
2563 spin_unlock(&inode
->i_lock
);
2565 complete(&wdata
->done
);
2566 collect_uncached_write_data(wdata
->ctx
);
2567 /* the below call can possibly free the last ref to aio ctx */
2568 kref_put(&wdata
->refcount
, cifs_uncached_writedata_release
);
2572 wdata_fill_from_iovec(struct cifs_writedata
*wdata
, struct iov_iter
*from
,
2573 size_t *len
, unsigned long *num_pages
)
2575 size_t save_len
, copied
, bytes
, cur_len
= *len
;
2576 unsigned long i
, nr_pages
= *num_pages
;
2579 for (i
= 0; i
< nr_pages
; i
++) {
2580 bytes
= min_t(const size_t, cur_len
, PAGE_SIZE
);
2581 copied
= copy_page_from_iter(wdata
->pages
[i
], 0, bytes
, from
);
2584 * If we didn't copy as much as we expected, then that
2585 * may mean we trod into an unmapped area. Stop copying
2586 * at that point. On the next pass through the big
2587 * loop, we'll likely end up getting a zero-length
2588 * write and bailing out of it.
2593 cur_len
= save_len
- cur_len
;
2597 * If we have no data to send, then that probably means that
2598 * the copy above failed altogether. That's most likely because
2599 * the address in the iovec was bogus. Return -EFAULT and let
2600 * the caller free anything we allocated and bail out.
2606 * i + 1 now represents the number of pages we actually used in
2607 * the copy phase above.
2614 cifs_resend_wdata(struct cifs_writedata
*wdata
, struct list_head
*wdata_list
,
2615 struct cifs_aio_ctx
*ctx
)
2618 struct cifs_credits credits
;
2620 struct TCP_Server_Info
*server
=
2621 tlink_tcon(wdata
->cfile
->tlink
)->ses
->server
;
2624 * Wait for credits to resend this wdata.
2625 * Note: we are attempting to resend the whole wdata not in segments
2628 rc
= server
->ops
->wait_mtu_credits(server
, wdata
->bytes
, &wsize
,
2634 if (wsize
< wdata
->bytes
) {
2635 add_credits_and_wake_if(server
, &credits
, 0);
2638 } while (wsize
< wdata
->bytes
);
2640 wdata
->credits
= credits
;
2642 while (rc
== -EAGAIN
) {
2644 if (wdata
->cfile
->invalidHandle
)
2645 rc
= cifs_reopen_file(wdata
->cfile
, false);
2647 rc
= server
->ops
->async_writev(wdata
,
2648 cifs_uncached_writedata_release
);
2652 list_add_tail(&wdata
->list
, wdata_list
);
2656 add_credits_and_wake_if(server
, &wdata
->credits
, 0);
2658 kref_put(&wdata
->refcount
, cifs_uncached_writedata_release
);
2664 cifs_write_from_iter(loff_t offset
, size_t len
, struct iov_iter
*from
,
2665 struct cifsFileInfo
*open_file
,
2666 struct cifs_sb_info
*cifs_sb
, struct list_head
*wdata_list
,
2667 struct cifs_aio_ctx
*ctx
)
2671 unsigned long nr_pages
, num_pages
, i
;
2672 struct cifs_writedata
*wdata
;
2673 struct iov_iter saved_from
= *from
;
2674 loff_t saved_offset
= offset
;
2676 struct TCP_Server_Info
*server
;
2677 struct page
**pagevec
;
2681 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
2682 pid
= open_file
->pid
;
2684 pid
= current
->tgid
;
2686 server
= tlink_tcon(open_file
->tlink
)->ses
->server
;
2691 struct cifs_credits credits_on_stack
;
2692 struct cifs_credits
*credits
= &credits_on_stack
;
2694 if (open_file
->invalidHandle
) {
2695 rc
= cifs_reopen_file(open_file
, false);
2702 rc
= server
->ops
->wait_mtu_credits(server
, cifs_sb
->wsize
,
2707 cur_len
= min_t(const size_t, len
, wsize
);
2709 if (ctx
->direct_io
) {
2712 result
= iov_iter_get_pages_alloc(
2713 from
, &pagevec
, cur_len
, &start
);
2716 "direct_writev couldn't get user pages "
2717 "(rc=%zd) iter type %d iov_offset %zd "
2720 from
->iov_offset
, from
->count
);
2724 add_credits_and_wake_if(server
, credits
, 0);
2727 cur_len
= (size_t)result
;
2728 iov_iter_advance(from
, cur_len
);
2731 (cur_len
+ start
+ PAGE_SIZE
- 1) / PAGE_SIZE
;
2733 wdata
= cifs_writedata_direct_alloc(pagevec
,
2734 cifs_uncached_writev_complete
);
2737 add_credits_and_wake_if(server
, credits
, 0);
2742 wdata
->page_offset
= start
;
2745 cur_len
- (PAGE_SIZE
- start
) -
2746 (nr_pages
- 2) * PAGE_SIZE
:
2749 nr_pages
= get_numpages(wsize
, len
, &cur_len
);
2750 wdata
= cifs_writedata_alloc(nr_pages
,
2751 cifs_uncached_writev_complete
);
2754 add_credits_and_wake_if(server
, credits
, 0);
2758 rc
= cifs_write_allocate_pages(wdata
->pages
, nr_pages
);
2760 kvfree(wdata
->pages
);
2762 add_credits_and_wake_if(server
, credits
, 0);
2766 num_pages
= nr_pages
;
2767 rc
= wdata_fill_from_iovec(
2768 wdata
, from
, &cur_len
, &num_pages
);
2770 for (i
= 0; i
< nr_pages
; i
++)
2771 put_page(wdata
->pages
[i
]);
2772 kvfree(wdata
->pages
);
2774 add_credits_and_wake_if(server
, credits
, 0);
2779 * Bring nr_pages down to the number of pages we
2780 * actually used, and free any pages that we didn't use.
2782 for ( ; nr_pages
> num_pages
; nr_pages
--)
2783 put_page(wdata
->pages
[nr_pages
- 1]);
2785 wdata
->tailsz
= cur_len
- ((nr_pages
- 1) * PAGE_SIZE
);
2788 wdata
->sync_mode
= WB_SYNC_ALL
;
2789 wdata
->nr_pages
= nr_pages
;
2790 wdata
->offset
= (__u64
)offset
;
2791 wdata
->cfile
= cifsFileInfo_get(open_file
);
2793 wdata
->bytes
= cur_len
;
2794 wdata
->pagesz
= PAGE_SIZE
;
2795 wdata
->credits
= credits_on_stack
;
2797 kref_get(&ctx
->refcount
);
2799 rc
= adjust_credits(server
, &wdata
->credits
, wdata
->bytes
);
2802 if (wdata
->cfile
->invalidHandle
)
2805 rc
= server
->ops
->async_writev(wdata
,
2806 cifs_uncached_writedata_release
);
2810 add_credits_and_wake_if(server
, &wdata
->credits
, 0);
2811 kref_put(&wdata
->refcount
,
2812 cifs_uncached_writedata_release
);
2813 if (rc
== -EAGAIN
) {
2815 iov_iter_advance(from
, offset
- saved_offset
);
2821 list_add_tail(&wdata
->list
, wdata_list
);
2830 static void collect_uncached_write_data(struct cifs_aio_ctx
*ctx
)
2832 struct cifs_writedata
*wdata
, *tmp
;
2833 struct cifs_tcon
*tcon
;
2834 struct cifs_sb_info
*cifs_sb
;
2835 struct dentry
*dentry
= ctx
->cfile
->dentry
;
2839 tcon
= tlink_tcon(ctx
->cfile
->tlink
);
2840 cifs_sb
= CIFS_SB(dentry
->d_sb
);
2842 mutex_lock(&ctx
->aio_mutex
);
2844 if (list_empty(&ctx
->list
)) {
2845 mutex_unlock(&ctx
->aio_mutex
);
2851 * Wait for and collect replies for any successful sends in order of
2852 * increasing offset. Once an error is hit, then return without waiting
2853 * for any more replies.
2856 list_for_each_entry_safe(wdata
, tmp
, &ctx
->list
, list
) {
2858 if (!try_wait_for_completion(&wdata
->done
)) {
2859 mutex_unlock(&ctx
->aio_mutex
);
2866 ctx
->total_len
+= wdata
->bytes
;
2868 /* resend call if it's a retryable error */
2869 if (rc
== -EAGAIN
) {
2870 struct list_head tmp_list
;
2871 struct iov_iter tmp_from
= ctx
->iter
;
2873 INIT_LIST_HEAD(&tmp_list
);
2874 list_del_init(&wdata
->list
);
2877 rc
= cifs_resend_wdata(
2878 wdata
, &tmp_list
, ctx
);
2880 iov_iter_advance(&tmp_from
,
2881 wdata
->offset
- ctx
->pos
);
2883 rc
= cifs_write_from_iter(wdata
->offset
,
2884 wdata
->bytes
, &tmp_from
,
2885 ctx
->cfile
, cifs_sb
, &tmp_list
,
2889 list_splice(&tmp_list
, &ctx
->list
);
2891 kref_put(&wdata
->refcount
,
2892 cifs_uncached_writedata_release
);
2896 list_del_init(&wdata
->list
);
2897 kref_put(&wdata
->refcount
, cifs_uncached_writedata_release
);
2900 if (!ctx
->direct_io
)
2901 for (i
= 0; i
< ctx
->npages
; i
++)
2902 put_page(ctx
->bv
[i
].bv_page
);
2904 cifs_stats_bytes_written(tcon
, ctx
->total_len
);
2905 set_bit(CIFS_INO_INVALID_MAPPING
, &CIFS_I(dentry
->d_inode
)->flags
);
2907 ctx
->rc
= (rc
== 0) ? ctx
->total_len
: rc
;
2909 mutex_unlock(&ctx
->aio_mutex
);
2911 if (ctx
->iocb
&& ctx
->iocb
->ki_complete
)
2912 ctx
->iocb
->ki_complete(ctx
->iocb
, ctx
->rc
, 0);
2914 complete(&ctx
->done
);
2917 static ssize_t
__cifs_writev(
2918 struct kiocb
*iocb
, struct iov_iter
*from
, bool direct
)
2920 struct file
*file
= iocb
->ki_filp
;
2921 ssize_t total_written
= 0;
2922 struct cifsFileInfo
*cfile
;
2923 struct cifs_tcon
*tcon
;
2924 struct cifs_sb_info
*cifs_sb
;
2925 struct cifs_aio_ctx
*ctx
;
2926 struct iov_iter saved_from
= *from
;
2927 size_t len
= iov_iter_count(from
);
2931 * iov_iter_get_pages_alloc doesn't work with ITER_KVEC.
2932 * In this case, fall back to non-direct write function.
2933 * this could be improved by getting pages directly in ITER_KVEC
2935 if (direct
&& from
->type
& ITER_KVEC
) {
2936 cifs_dbg(FYI
, "use non-direct cifs_writev for kvec I/O\n");
2940 rc
= generic_write_checks(iocb
, from
);
2944 cifs_sb
= CIFS_FILE_SB(file
);
2945 cfile
= file
->private_data
;
2946 tcon
= tlink_tcon(cfile
->tlink
);
2948 if (!tcon
->ses
->server
->ops
->async_writev
)
2951 ctx
= cifs_aio_ctx_alloc();
2955 ctx
->cfile
= cifsFileInfo_get(cfile
);
2957 if (!is_sync_kiocb(iocb
))
2960 ctx
->pos
= iocb
->ki_pos
;
2963 ctx
->direct_io
= true;
2967 rc
= setup_aio_ctx_iter(ctx
, from
, WRITE
);
2969 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
2974 /* grab a lock here due to read response handlers can access ctx */
2975 mutex_lock(&ctx
->aio_mutex
);
2977 rc
= cifs_write_from_iter(iocb
->ki_pos
, ctx
->len
, &saved_from
,
2978 cfile
, cifs_sb
, &ctx
->list
, ctx
);
2981 * If at least one write was successfully sent, then discard any rc
2982 * value from the later writes. If the other write succeeds, then
2983 * we'll end up returning whatever was written. If it fails, then
2984 * we'll get a new rc value from that.
2986 if (!list_empty(&ctx
->list
))
2989 mutex_unlock(&ctx
->aio_mutex
);
2992 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
2996 if (!is_sync_kiocb(iocb
)) {
2997 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
2998 return -EIOCBQUEUED
;
3001 rc
= wait_for_completion_killable(&ctx
->done
);
3003 mutex_lock(&ctx
->aio_mutex
);
3004 ctx
->rc
= rc
= -EINTR
;
3005 total_written
= ctx
->total_len
;
3006 mutex_unlock(&ctx
->aio_mutex
);
3009 total_written
= ctx
->total_len
;
3012 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
3014 if (unlikely(!total_written
))
3017 iocb
->ki_pos
+= total_written
;
3018 return total_written
;
3021 ssize_t
cifs_direct_writev(struct kiocb
*iocb
, struct iov_iter
*from
)
3023 return __cifs_writev(iocb
, from
, true);
3026 ssize_t
cifs_user_writev(struct kiocb
*iocb
, struct iov_iter
*from
)
3028 return __cifs_writev(iocb
, from
, false);
3032 cifs_writev(struct kiocb
*iocb
, struct iov_iter
*from
)
3034 struct file
*file
= iocb
->ki_filp
;
3035 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)file
->private_data
;
3036 struct inode
*inode
= file
->f_mapping
->host
;
3037 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
3038 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
3043 * We need to hold the sem to be sure nobody modifies lock list
3044 * with a brlock that prevents writing.
3046 down_read(&cinode
->lock_sem
);
3048 rc
= generic_write_checks(iocb
, from
);
3052 if (!cifs_find_lock_conflict(cfile
, iocb
->ki_pos
, iov_iter_count(from
),
3053 server
->vals
->exclusive_lock_type
, 0,
3054 NULL
, CIFS_WRITE_OP
))
3055 rc
= __generic_file_write_iter(iocb
, from
);
3059 up_read(&cinode
->lock_sem
);
3060 inode_unlock(inode
);
3063 rc
= generic_write_sync(iocb
, rc
);
3068 cifs_strict_writev(struct kiocb
*iocb
, struct iov_iter
*from
)
3070 struct inode
*inode
= file_inode(iocb
->ki_filp
);
3071 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
3072 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
3073 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)
3074 iocb
->ki_filp
->private_data
;
3075 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
3078 written
= cifs_get_writer(cinode
);
3082 if (CIFS_CACHE_WRITE(cinode
)) {
3083 if (cap_unix(tcon
->ses
) &&
3084 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
))
3085 && ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0)) {
3086 written
= generic_file_write_iter(iocb
, from
);
3089 written
= cifs_writev(iocb
, from
);
3093 * For non-oplocked files in strict cache mode we need to write the data
3094 * to the server exactly from the pos to pos+len-1 rather than flush all
3095 * affected pages because it may cause a error with mandatory locks on
3096 * these pages but not on the region from pos to ppos+len-1.
3098 written
= cifs_user_writev(iocb
, from
);
3099 if (CIFS_CACHE_READ(cinode
)) {
3101 * We have read level caching and we have just sent a write
3102 * request to the server thus making data in the cache stale.
3103 * Zap the cache and set oplock/lease level to NONE to avoid
3104 * reading stale data from the cache. All subsequent read
3105 * operations will read new data from the server.
3107 cifs_zap_mapping(inode
);
3108 cifs_dbg(FYI
, "Set Oplock/Lease to NONE for inode=%p after write\n",
3113 cifs_put_writer(cinode
);
3117 static struct cifs_readdata
*
3118 cifs_readdata_direct_alloc(struct page
**pages
, work_func_t complete
)
3120 struct cifs_readdata
*rdata
;
3122 rdata
= kzalloc(sizeof(*rdata
), GFP_KERNEL
);
3123 if (rdata
!= NULL
) {
3124 rdata
->pages
= pages
;
3125 kref_init(&rdata
->refcount
);
3126 INIT_LIST_HEAD(&rdata
->list
);
3127 init_completion(&rdata
->done
);
3128 INIT_WORK(&rdata
->work
, complete
);
3134 static struct cifs_readdata
*
3135 cifs_readdata_alloc(unsigned int nr_pages
, work_func_t complete
)
3137 struct page
**pages
=
3138 kcalloc(nr_pages
, sizeof(struct page
*), GFP_KERNEL
);
3139 struct cifs_readdata
*ret
= NULL
;
3142 ret
= cifs_readdata_direct_alloc(pages
, complete
);
3151 cifs_readdata_release(struct kref
*refcount
)
3153 struct cifs_readdata
*rdata
= container_of(refcount
,
3154 struct cifs_readdata
, refcount
);
3155 #ifdef CONFIG_CIFS_SMB_DIRECT
3157 smbd_deregister_mr(rdata
->mr
);
3162 cifsFileInfo_put(rdata
->cfile
);
3164 kvfree(rdata
->pages
);
3169 cifs_read_allocate_pages(struct cifs_readdata
*rdata
, unsigned int nr_pages
)
3175 for (i
= 0; i
< nr_pages
; i
++) {
3176 page
= alloc_page(GFP_KERNEL
|__GFP_HIGHMEM
);
3181 rdata
->pages
[i
] = page
;
3185 for (i
= 0; i
< nr_pages
; i
++) {
3186 put_page(rdata
->pages
[i
]);
3187 rdata
->pages
[i
] = NULL
;
3194 cifs_uncached_readdata_release(struct kref
*refcount
)
3196 struct cifs_readdata
*rdata
= container_of(refcount
,
3197 struct cifs_readdata
, refcount
);
3200 kref_put(&rdata
->ctx
->refcount
, cifs_aio_ctx_release
);
3201 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
3202 put_page(rdata
->pages
[i
]);
3204 cifs_readdata_release(refcount
);
3208 * cifs_readdata_to_iov - copy data from pages in response to an iovec
3209 * @rdata: the readdata response with list of pages holding data
3210 * @iter: destination for our data
3212 * This function copies data from a list of pages in a readdata response into
3213 * an array of iovecs. It will first calculate where the data should go
3214 * based on the info in the readdata and then copy the data into that spot.
3217 cifs_readdata_to_iov(struct cifs_readdata
*rdata
, struct iov_iter
*iter
)
3219 size_t remaining
= rdata
->got_bytes
;
3222 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
3223 struct page
*page
= rdata
->pages
[i
];
3224 size_t copy
= min_t(size_t, remaining
, PAGE_SIZE
);
3227 if (unlikely(iov_iter_is_pipe(iter
))) {
3228 void *addr
= kmap_atomic(page
);
3230 written
= copy_to_iter(addr
, copy
, iter
);
3231 kunmap_atomic(addr
);
3233 written
= copy_page_to_iter(page
, 0, copy
, iter
);
3234 remaining
-= written
;
3235 if (written
< copy
&& iov_iter_count(iter
) > 0)
3238 return remaining
? -EFAULT
: 0;
3241 static void collect_uncached_read_data(struct cifs_aio_ctx
*ctx
);
3244 cifs_uncached_readv_complete(struct work_struct
*work
)
3246 struct cifs_readdata
*rdata
= container_of(work
,
3247 struct cifs_readdata
, work
);
3249 complete(&rdata
->done
);
3250 collect_uncached_read_data(rdata
->ctx
);
3251 /* the below call can possibly free the last ref to aio ctx */
3252 kref_put(&rdata
->refcount
, cifs_uncached_readdata_release
);
3256 uncached_fill_pages(struct TCP_Server_Info
*server
,
3257 struct cifs_readdata
*rdata
, struct iov_iter
*iter
,
3262 unsigned int nr_pages
= rdata
->nr_pages
;
3263 unsigned int page_offset
= rdata
->page_offset
;
3265 rdata
->got_bytes
= 0;
3266 rdata
->tailsz
= PAGE_SIZE
;
3267 for (i
= 0; i
< nr_pages
; i
++) {
3268 struct page
*page
= rdata
->pages
[i
];
3270 unsigned int segment_size
= rdata
->pagesz
;
3273 segment_size
-= page_offset
;
3279 /* no need to hold page hostage */
3280 rdata
->pages
[i
] = NULL
;
3287 if (len
>= segment_size
)
3288 /* enough data to fill the page */
3291 rdata
->tailsz
= len
;
3295 result
= copy_page_from_iter(
3296 page
, page_offset
, n
, iter
);
3297 #ifdef CONFIG_CIFS_SMB_DIRECT
3302 result
= cifs_read_page_from_socket(
3303 server
, page
, page_offset
, n
);
3307 rdata
->got_bytes
+= result
;
3310 return rdata
->got_bytes
> 0 && result
!= -ECONNABORTED
?
3311 rdata
->got_bytes
: result
;
3315 cifs_uncached_read_into_pages(struct TCP_Server_Info
*server
,
3316 struct cifs_readdata
*rdata
, unsigned int len
)
3318 return uncached_fill_pages(server
, rdata
, NULL
, len
);
3322 cifs_uncached_copy_into_pages(struct TCP_Server_Info
*server
,
3323 struct cifs_readdata
*rdata
,
3324 struct iov_iter
*iter
)
3326 return uncached_fill_pages(server
, rdata
, iter
, iter
->count
);
3329 static int cifs_resend_rdata(struct cifs_readdata
*rdata
,
3330 struct list_head
*rdata_list
,
3331 struct cifs_aio_ctx
*ctx
)
3334 struct cifs_credits credits
;
3336 struct TCP_Server_Info
*server
=
3337 tlink_tcon(rdata
->cfile
->tlink
)->ses
->server
;
3340 * Wait for credits to resend this rdata.
3341 * Note: we are attempting to resend the whole rdata not in segments
3344 rc
= server
->ops
->wait_mtu_credits(server
, rdata
->bytes
,
3350 if (rsize
< rdata
->bytes
) {
3351 add_credits_and_wake_if(server
, &credits
, 0);
3354 } while (rsize
< rdata
->bytes
);
3356 rdata
->credits
= credits
;
3358 while (rc
== -EAGAIN
) {
3360 if (rdata
->cfile
->invalidHandle
)
3361 rc
= cifs_reopen_file(rdata
->cfile
, true);
3363 rc
= server
->ops
->async_readv(rdata
);
3367 /* Add to aio pending list */
3368 list_add_tail(&rdata
->list
, rdata_list
);
3372 add_credits_and_wake_if(server
, &rdata
->credits
, 0);
3374 kref_put(&rdata
->refcount
,
3375 cifs_uncached_readdata_release
);
3381 cifs_send_async_read(loff_t offset
, size_t len
, struct cifsFileInfo
*open_file
,
3382 struct cifs_sb_info
*cifs_sb
, struct list_head
*rdata_list
,
3383 struct cifs_aio_ctx
*ctx
)
3385 struct cifs_readdata
*rdata
;
3386 unsigned int npages
, rsize
;
3387 struct cifs_credits credits_on_stack
;
3388 struct cifs_credits
*credits
= &credits_on_stack
;
3392 struct TCP_Server_Info
*server
;
3393 struct page
**pagevec
;
3395 struct iov_iter direct_iov
= ctx
->iter
;
3397 server
= tlink_tcon(open_file
->tlink
)->ses
->server
;
3399 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
3400 pid
= open_file
->pid
;
3402 pid
= current
->tgid
;
3405 iov_iter_advance(&direct_iov
, offset
- ctx
->pos
);
3408 if (open_file
->invalidHandle
) {
3409 rc
= cifs_reopen_file(open_file
, true);
3416 rc
= server
->ops
->wait_mtu_credits(server
, cifs_sb
->rsize
,
3421 cur_len
= min_t(const size_t, len
, rsize
);
3423 if (ctx
->direct_io
) {
3426 result
= iov_iter_get_pages_alloc(
3427 &direct_iov
, &pagevec
,
3431 "couldn't get user pages (rc=%zd)"
3433 " iov_offset %zd count %zd\n",
3434 result
, direct_iov
.type
,
3435 direct_iov
.iov_offset
,
3440 add_credits_and_wake_if(server
, credits
, 0);
3443 cur_len
= (size_t)result
;
3444 iov_iter_advance(&direct_iov
, cur_len
);
3446 rdata
= cifs_readdata_direct_alloc(
3447 pagevec
, cifs_uncached_readv_complete
);
3449 add_credits_and_wake_if(server
, credits
, 0);
3454 npages
= (cur_len
+ start
+ PAGE_SIZE
-1) / PAGE_SIZE
;
3455 rdata
->page_offset
= start
;
3456 rdata
->tailsz
= npages
> 1 ?
3457 cur_len
-(PAGE_SIZE
-start
)-(npages
-2)*PAGE_SIZE
:
3462 npages
= DIV_ROUND_UP(cur_len
, PAGE_SIZE
);
3463 /* allocate a readdata struct */
3464 rdata
= cifs_readdata_alloc(npages
,
3465 cifs_uncached_readv_complete
);
3467 add_credits_and_wake_if(server
, credits
, 0);
3472 rc
= cifs_read_allocate_pages(rdata
, npages
);
3474 kvfree(rdata
->pages
);
3476 add_credits_and_wake_if(server
, credits
, 0);
3480 rdata
->tailsz
= PAGE_SIZE
;
3483 rdata
->cfile
= cifsFileInfo_get(open_file
);
3484 rdata
->nr_pages
= npages
;
3485 rdata
->offset
= offset
;
3486 rdata
->bytes
= cur_len
;
3488 rdata
->pagesz
= PAGE_SIZE
;
3489 rdata
->read_into_pages
= cifs_uncached_read_into_pages
;
3490 rdata
->copy_into_pages
= cifs_uncached_copy_into_pages
;
3491 rdata
->credits
= credits_on_stack
;
3493 kref_get(&ctx
->refcount
);
3495 rc
= adjust_credits(server
, &rdata
->credits
, rdata
->bytes
);
3498 if (rdata
->cfile
->invalidHandle
)
3501 rc
= server
->ops
->async_readv(rdata
);
3505 add_credits_and_wake_if(server
, &rdata
->credits
, 0);
3506 kref_put(&rdata
->refcount
,
3507 cifs_uncached_readdata_release
);
3508 if (rc
== -EAGAIN
) {
3509 iov_iter_revert(&direct_iov
, cur_len
);
3515 list_add_tail(&rdata
->list
, rdata_list
);
3524 collect_uncached_read_data(struct cifs_aio_ctx
*ctx
)
3526 struct cifs_readdata
*rdata
, *tmp
;
3527 struct iov_iter
*to
= &ctx
->iter
;
3528 struct cifs_sb_info
*cifs_sb
;
3529 struct cifs_tcon
*tcon
;
3533 tcon
= tlink_tcon(ctx
->cfile
->tlink
);
3534 cifs_sb
= CIFS_SB(ctx
->cfile
->dentry
->d_sb
);
3536 mutex_lock(&ctx
->aio_mutex
);
3538 if (list_empty(&ctx
->list
)) {
3539 mutex_unlock(&ctx
->aio_mutex
);
3544 /* the loop below should proceed in the order of increasing offsets */
3546 list_for_each_entry_safe(rdata
, tmp
, &ctx
->list
, list
) {
3548 if (!try_wait_for_completion(&rdata
->done
)) {
3549 mutex_unlock(&ctx
->aio_mutex
);
3553 if (rdata
->result
== -EAGAIN
) {
3554 /* resend call if it's a retryable error */
3555 struct list_head tmp_list
;
3556 unsigned int got_bytes
= rdata
->got_bytes
;
3558 list_del_init(&rdata
->list
);
3559 INIT_LIST_HEAD(&tmp_list
);
3562 * Got a part of data and then reconnect has
3563 * happened -- fill the buffer and continue
3566 if (got_bytes
&& got_bytes
< rdata
->bytes
) {
3568 if (!ctx
->direct_io
)
3569 rc
= cifs_readdata_to_iov(rdata
, to
);
3571 kref_put(&rdata
->refcount
,
3572 cifs_uncached_readdata_release
);
3577 if (ctx
->direct_io
) {
3579 * Re-use rdata as this is a
3582 rc
= cifs_resend_rdata(
3586 rc
= cifs_send_async_read(
3587 rdata
->offset
+ got_bytes
,
3588 rdata
->bytes
- got_bytes
,
3589 rdata
->cfile
, cifs_sb
,
3592 kref_put(&rdata
->refcount
,
3593 cifs_uncached_readdata_release
);
3596 list_splice(&tmp_list
, &ctx
->list
);
3599 } else if (rdata
->result
)
3601 else if (!ctx
->direct_io
)
3602 rc
= cifs_readdata_to_iov(rdata
, to
);
3604 /* if there was a short read -- discard anything left */
3605 if (rdata
->got_bytes
&& rdata
->got_bytes
< rdata
->bytes
)
3608 ctx
->total_len
+= rdata
->got_bytes
;
3610 list_del_init(&rdata
->list
);
3611 kref_put(&rdata
->refcount
, cifs_uncached_readdata_release
);
3614 if (!ctx
->direct_io
) {
3615 for (i
= 0; i
< ctx
->npages
; i
++) {
3616 if (ctx
->should_dirty
)
3617 set_page_dirty(ctx
->bv
[i
].bv_page
);
3618 put_page(ctx
->bv
[i
].bv_page
);
3621 ctx
->total_len
= ctx
->len
- iov_iter_count(to
);
3624 /* mask nodata case */
3628 ctx
->rc
= (rc
== 0) ? ctx
->total_len
: rc
;
3630 mutex_unlock(&ctx
->aio_mutex
);
3632 if (ctx
->iocb
&& ctx
->iocb
->ki_complete
)
3633 ctx
->iocb
->ki_complete(ctx
->iocb
, ctx
->rc
, 0);
3635 complete(&ctx
->done
);
3638 static ssize_t
__cifs_readv(
3639 struct kiocb
*iocb
, struct iov_iter
*to
, bool direct
)
3642 struct file
*file
= iocb
->ki_filp
;
3643 struct cifs_sb_info
*cifs_sb
;
3644 struct cifsFileInfo
*cfile
;
3645 struct cifs_tcon
*tcon
;
3646 ssize_t rc
, total_read
= 0;
3647 loff_t offset
= iocb
->ki_pos
;
3648 struct cifs_aio_ctx
*ctx
;
3651 * iov_iter_get_pages_alloc() doesn't work with ITER_KVEC,
3652 * fall back to data copy read path
3653 * this could be improved by getting pages directly in ITER_KVEC
3655 if (direct
&& to
->type
& ITER_KVEC
) {
3656 cifs_dbg(FYI
, "use non-direct cifs_user_readv for kvec I/O\n");
3660 len
= iov_iter_count(to
);
3664 cifs_sb
= CIFS_FILE_SB(file
);
3665 cfile
= file
->private_data
;
3666 tcon
= tlink_tcon(cfile
->tlink
);
3668 if (!tcon
->ses
->server
->ops
->async_readv
)
3671 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
3672 cifs_dbg(FYI
, "attempting read on write only file instance\n");
3674 ctx
= cifs_aio_ctx_alloc();
3678 ctx
->cfile
= cifsFileInfo_get(cfile
);
3680 if (!is_sync_kiocb(iocb
))
3683 if (iter_is_iovec(to
))
3684 ctx
->should_dirty
= true;
3688 ctx
->direct_io
= true;
3692 rc
= setup_aio_ctx_iter(ctx
, to
, READ
);
3694 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
3700 /* grab a lock here due to read response handlers can access ctx */
3701 mutex_lock(&ctx
->aio_mutex
);
3703 rc
= cifs_send_async_read(offset
, len
, cfile
, cifs_sb
, &ctx
->list
, ctx
);
3705 /* if at least one read request send succeeded, then reset rc */
3706 if (!list_empty(&ctx
->list
))
3709 mutex_unlock(&ctx
->aio_mutex
);
3712 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
3716 if (!is_sync_kiocb(iocb
)) {
3717 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
3718 return -EIOCBQUEUED
;
3721 rc
= wait_for_completion_killable(&ctx
->done
);
3723 mutex_lock(&ctx
->aio_mutex
);
3724 ctx
->rc
= rc
= -EINTR
;
3725 total_read
= ctx
->total_len
;
3726 mutex_unlock(&ctx
->aio_mutex
);
3729 total_read
= ctx
->total_len
;
3732 kref_put(&ctx
->refcount
, cifs_aio_ctx_release
);
3735 iocb
->ki_pos
+= total_read
;
3741 ssize_t
cifs_direct_readv(struct kiocb
*iocb
, struct iov_iter
*to
)
3743 return __cifs_readv(iocb
, to
, true);
3746 ssize_t
cifs_user_readv(struct kiocb
*iocb
, struct iov_iter
*to
)
3748 return __cifs_readv(iocb
, to
, false);
3752 cifs_strict_readv(struct kiocb
*iocb
, struct iov_iter
*to
)
3754 struct inode
*inode
= file_inode(iocb
->ki_filp
);
3755 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
3756 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
3757 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)
3758 iocb
->ki_filp
->private_data
;
3759 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
3763 * In strict cache mode we need to read from the server all the time
3764 * if we don't have level II oplock because the server can delay mtime
3765 * change - so we can't make a decision about inode invalidating.
3766 * And we can also fail with pagereading if there are mandatory locks
3767 * on pages affected by this read but not on the region from pos to
3770 if (!CIFS_CACHE_READ(cinode
))
3771 return cifs_user_readv(iocb
, to
);
3773 if (cap_unix(tcon
->ses
) &&
3774 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
3775 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
3776 return generic_file_read_iter(iocb
, to
);
3779 * We need to hold the sem to be sure nobody modifies lock list
3780 * with a brlock that prevents reading.
3782 down_read(&cinode
->lock_sem
);
3783 if (!cifs_find_lock_conflict(cfile
, iocb
->ki_pos
, iov_iter_count(to
),
3784 tcon
->ses
->server
->vals
->shared_lock_type
,
3785 0, NULL
, CIFS_READ_OP
))
3786 rc
= generic_file_read_iter(iocb
, to
);
3787 up_read(&cinode
->lock_sem
);
3792 cifs_read(struct file
*file
, char *read_data
, size_t read_size
, loff_t
*offset
)
3795 unsigned int bytes_read
= 0;
3796 unsigned int total_read
;
3797 unsigned int current_read_size
;
3799 struct cifs_sb_info
*cifs_sb
;
3800 struct cifs_tcon
*tcon
;
3801 struct TCP_Server_Info
*server
;
3804 struct cifsFileInfo
*open_file
;
3805 struct cifs_io_parms io_parms
;
3806 int buf_type
= CIFS_NO_BUFFER
;
3810 cifs_sb
= CIFS_FILE_SB(file
);
3812 /* FIXME: set up handlers for larger reads and/or convert to async */
3813 rsize
= min_t(unsigned int, cifs_sb
->rsize
, CIFSMaxBufSize
);
3815 if (file
->private_data
== NULL
) {
3820 open_file
= file
->private_data
;
3821 tcon
= tlink_tcon(open_file
->tlink
);
3822 server
= tcon
->ses
->server
;
3824 if (!server
->ops
->sync_read
) {
3829 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
3830 pid
= open_file
->pid
;
3832 pid
= current
->tgid
;
3834 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
3835 cifs_dbg(FYI
, "attempting read on write only file instance\n");
3837 for (total_read
= 0, cur_offset
= read_data
; read_size
> total_read
;
3838 total_read
+= bytes_read
, cur_offset
+= bytes_read
) {
3840 current_read_size
= min_t(uint
, read_size
- total_read
,
3843 * For windows me and 9x we do not want to request more
3844 * than it negotiated since it will refuse the read
3847 if ((tcon
->ses
) && !(tcon
->ses
->capabilities
&
3848 tcon
->ses
->server
->vals
->cap_large_files
)) {
3849 current_read_size
= min_t(uint
,
3850 current_read_size
, CIFSMaxBufSize
);
3852 if (open_file
->invalidHandle
) {
3853 rc
= cifs_reopen_file(open_file
, true);
3858 io_parms
.tcon
= tcon
;
3859 io_parms
.offset
= *offset
;
3860 io_parms
.length
= current_read_size
;
3861 rc
= server
->ops
->sync_read(xid
, &open_file
->fid
, &io_parms
,
3862 &bytes_read
, &cur_offset
,
3864 } while (rc
== -EAGAIN
);
3866 if (rc
|| (bytes_read
== 0)) {
3874 cifs_stats_bytes_read(tcon
, total_read
);
3875 *offset
+= bytes_read
;
3883 * If the page is mmap'ed into a process' page tables, then we need to make
3884 * sure that it doesn't change while being written back.
3887 cifs_page_mkwrite(struct vm_fault
*vmf
)
3889 struct page
*page
= vmf
->page
;
3892 return VM_FAULT_LOCKED
;
3895 static const struct vm_operations_struct cifs_file_vm_ops
= {
3896 .fault
= filemap_fault
,
3897 .map_pages
= filemap_map_pages
,
3898 .page_mkwrite
= cifs_page_mkwrite
,
3901 int cifs_file_strict_mmap(struct file
*file
, struct vm_area_struct
*vma
)
3904 struct inode
*inode
= file_inode(file
);
3908 if (!CIFS_CACHE_READ(CIFS_I(inode
)))
3909 rc
= cifs_zap_mapping(inode
);
3911 rc
= generic_file_mmap(file
, vma
);
3913 vma
->vm_ops
= &cifs_file_vm_ops
;
3919 int cifs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
3925 rc
= cifs_revalidate_file(file
);
3927 cifs_dbg(FYI
, "Validation prior to mmap failed, error=%d\n",
3930 rc
= generic_file_mmap(file
, vma
);
3932 vma
->vm_ops
= &cifs_file_vm_ops
;
3939 cifs_readv_complete(struct work_struct
*work
)
3941 unsigned int i
, got_bytes
;
3942 struct cifs_readdata
*rdata
= container_of(work
,
3943 struct cifs_readdata
, work
);
3945 got_bytes
= rdata
->got_bytes
;
3946 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
3947 struct page
*page
= rdata
->pages
[i
];
3949 lru_cache_add_file(page
);
3951 if (rdata
->result
== 0 ||
3952 (rdata
->result
== -EAGAIN
&& got_bytes
)) {
3953 flush_dcache_page(page
);
3954 SetPageUptodate(page
);
3959 if (rdata
->result
== 0 ||
3960 (rdata
->result
== -EAGAIN
&& got_bytes
))
3961 cifs_readpage_to_fscache(rdata
->mapping
->host
, page
);
3963 got_bytes
-= min_t(unsigned int, PAGE_SIZE
, got_bytes
);
3966 rdata
->pages
[i
] = NULL
;
3968 kref_put(&rdata
->refcount
, cifs_readdata_release
);
3972 readpages_fill_pages(struct TCP_Server_Info
*server
,
3973 struct cifs_readdata
*rdata
, struct iov_iter
*iter
,
3980 unsigned int nr_pages
= rdata
->nr_pages
;
3981 unsigned int page_offset
= rdata
->page_offset
;
3983 /* determine the eof that the server (probably) has */
3984 eof
= CIFS_I(rdata
->mapping
->host
)->server_eof
;
3985 eof_index
= eof
? (eof
- 1) >> PAGE_SHIFT
: 0;
3986 cifs_dbg(FYI
, "eof=%llu eof_index=%lu\n", eof
, eof_index
);
3988 rdata
->got_bytes
= 0;
3989 rdata
->tailsz
= PAGE_SIZE
;
3990 for (i
= 0; i
< nr_pages
; i
++) {
3991 struct page
*page
= rdata
->pages
[i
];
3992 unsigned int to_read
= rdata
->pagesz
;
3996 to_read
-= page_offset
;
4002 if (len
>= to_read
) {
4004 } else if (len
> 0) {
4005 /* enough for partial page, fill and zero the rest */
4006 zero_user(page
, len
+ page_offset
, to_read
- len
);
4007 n
= rdata
->tailsz
= len
;
4009 } else if (page
->index
> eof_index
) {
4011 * The VFS will not try to do readahead past the
4012 * i_size, but it's possible that we have outstanding
4013 * writes with gaps in the middle and the i_size hasn't
4014 * caught up yet. Populate those with zeroed out pages
4015 * to prevent the VFS from repeatedly attempting to
4016 * fill them until the writes are flushed.
4018 zero_user(page
, 0, PAGE_SIZE
);
4019 lru_cache_add_file(page
);
4020 flush_dcache_page(page
);
4021 SetPageUptodate(page
);
4024 rdata
->pages
[i
] = NULL
;
4028 /* no need to hold page hostage */
4029 lru_cache_add_file(page
);
4032 rdata
->pages
[i
] = NULL
;
4038 result
= copy_page_from_iter(
4039 page
, page_offset
, n
, iter
);
4040 #ifdef CONFIG_CIFS_SMB_DIRECT
4045 result
= cifs_read_page_from_socket(
4046 server
, page
, page_offset
, n
);
4050 rdata
->got_bytes
+= result
;
4053 return rdata
->got_bytes
> 0 && result
!= -ECONNABORTED
?
4054 rdata
->got_bytes
: result
;
4058 cifs_readpages_read_into_pages(struct TCP_Server_Info
*server
,
4059 struct cifs_readdata
*rdata
, unsigned int len
)
4061 return readpages_fill_pages(server
, rdata
, NULL
, len
);
4065 cifs_readpages_copy_into_pages(struct TCP_Server_Info
*server
,
4066 struct cifs_readdata
*rdata
,
4067 struct iov_iter
*iter
)
4069 return readpages_fill_pages(server
, rdata
, iter
, iter
->count
);
4073 readpages_get_pages(struct address_space
*mapping
, struct list_head
*page_list
,
4074 unsigned int rsize
, struct list_head
*tmplist
,
4075 unsigned int *nr_pages
, loff_t
*offset
, unsigned int *bytes
)
4077 struct page
*page
, *tpage
;
4078 unsigned int expected_index
;
4080 gfp_t gfp
= readahead_gfp_mask(mapping
);
4082 INIT_LIST_HEAD(tmplist
);
4084 page
= lru_to_page(page_list
);
4087 * Lock the page and put it in the cache. Since no one else
4088 * should have access to this page, we're safe to simply set
4089 * PG_locked without checking it first.
4091 __SetPageLocked(page
);
4092 rc
= add_to_page_cache_locked(page
, mapping
,
4095 /* give up if we can't stick it in the cache */
4097 __ClearPageLocked(page
);
4101 /* move first page to the tmplist */
4102 *offset
= (loff_t
)page
->index
<< PAGE_SHIFT
;
4105 list_move_tail(&page
->lru
, tmplist
);
4107 /* now try and add more pages onto the request */
4108 expected_index
= page
->index
+ 1;
4109 list_for_each_entry_safe_reverse(page
, tpage
, page_list
, lru
) {
4110 /* discontinuity ? */
4111 if (page
->index
!= expected_index
)
4114 /* would this page push the read over the rsize? */
4115 if (*bytes
+ PAGE_SIZE
> rsize
)
4118 __SetPageLocked(page
);
4119 if (add_to_page_cache_locked(page
, mapping
, page
->index
, gfp
)) {
4120 __ClearPageLocked(page
);
4123 list_move_tail(&page
->lru
, tmplist
);
4124 (*bytes
) += PAGE_SIZE
;
4131 static int cifs_readpages(struct file
*file
, struct address_space
*mapping
,
4132 struct list_head
*page_list
, unsigned num_pages
)
4135 struct list_head tmplist
;
4136 struct cifsFileInfo
*open_file
= file
->private_data
;
4137 struct cifs_sb_info
*cifs_sb
= CIFS_FILE_SB(file
);
4138 struct TCP_Server_Info
*server
;
4144 * Reads as many pages as possible from fscache. Returns -ENOBUFS
4145 * immediately if the cookie is negative
4147 * After this point, every page in the list might have PG_fscache set,
4148 * so we will need to clean that up off of every page we don't use.
4150 rc
= cifs_readpages_from_fscache(mapping
->host
, mapping
, page_list
,
4157 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
4158 pid
= open_file
->pid
;
4160 pid
= current
->tgid
;
4163 server
= tlink_tcon(open_file
->tlink
)->ses
->server
;
4165 cifs_dbg(FYI
, "%s: file=%p mapping=%p num_pages=%u\n",
4166 __func__
, file
, mapping
, num_pages
);
4169 * Start with the page at end of list and move it to private
4170 * list. Do the same with any following pages until we hit
4171 * the rsize limit, hit an index discontinuity, or run out of
4172 * pages. Issue the async read and then start the loop again
4173 * until the list is empty.
4175 * Note that list order is important. The page_list is in
4176 * the order of declining indexes. When we put the pages in
4177 * the rdata->pages, then we want them in increasing order.
4179 while (!list_empty(page_list
)) {
4180 unsigned int i
, nr_pages
, bytes
, rsize
;
4182 struct page
*page
, *tpage
;
4183 struct cifs_readdata
*rdata
;
4184 struct cifs_credits credits_on_stack
;
4185 struct cifs_credits
*credits
= &credits_on_stack
;
4187 if (open_file
->invalidHandle
) {
4188 rc
= cifs_reopen_file(open_file
, true);
4195 rc
= server
->ops
->wait_mtu_credits(server
, cifs_sb
->rsize
,
4201 * Give up immediately if rsize is too small to read an entire
4202 * page. The VFS will fall back to readpage. We should never
4203 * reach this point however since we set ra_pages to 0 when the
4204 * rsize is smaller than a cache page.
4206 if (unlikely(rsize
< PAGE_SIZE
)) {
4207 add_credits_and_wake_if(server
, credits
, 0);
4212 rc
= readpages_get_pages(mapping
, page_list
, rsize
, &tmplist
,
4213 &nr_pages
, &offset
, &bytes
);
4215 add_credits_and_wake_if(server
, credits
, 0);
4219 rdata
= cifs_readdata_alloc(nr_pages
, cifs_readv_complete
);
4221 /* best to give up if we're out of mem */
4222 list_for_each_entry_safe(page
, tpage
, &tmplist
, lru
) {
4223 list_del(&page
->lru
);
4224 lru_cache_add_file(page
);
4229 add_credits_and_wake_if(server
, credits
, 0);
4233 rdata
->cfile
= cifsFileInfo_get(open_file
);
4234 rdata
->mapping
= mapping
;
4235 rdata
->offset
= offset
;
4236 rdata
->bytes
= bytes
;
4238 rdata
->pagesz
= PAGE_SIZE
;
4239 rdata
->tailsz
= PAGE_SIZE
;
4240 rdata
->read_into_pages
= cifs_readpages_read_into_pages
;
4241 rdata
->copy_into_pages
= cifs_readpages_copy_into_pages
;
4242 rdata
->credits
= credits_on_stack
;
4244 list_for_each_entry_safe(page
, tpage
, &tmplist
, lru
) {
4245 list_del(&page
->lru
);
4246 rdata
->pages
[rdata
->nr_pages
++] = page
;
4249 rc
= adjust_credits(server
, &rdata
->credits
, rdata
->bytes
);
4252 if (rdata
->cfile
->invalidHandle
)
4255 rc
= server
->ops
->async_readv(rdata
);
4259 add_credits_and_wake_if(server
, &rdata
->credits
, 0);
4260 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
4261 page
= rdata
->pages
[i
];
4262 lru_cache_add_file(page
);
4266 /* Fallback to the readpage in error/reconnect cases */
4267 kref_put(&rdata
->refcount
, cifs_readdata_release
);
4271 kref_put(&rdata
->refcount
, cifs_readdata_release
);
4274 /* Any pages that have been shown to fscache but didn't get added to
4275 * the pagecache must be uncached before they get returned to the
4278 cifs_fscache_readpages_cancel(mapping
->host
, page_list
);
4284 * cifs_readpage_worker must be called with the page pinned
4286 static int cifs_readpage_worker(struct file
*file
, struct page
*page
,
4292 /* Is the page cached? */
4293 rc
= cifs_readpage_from_fscache(file_inode(file
), page
);
4297 read_data
= kmap(page
);
4298 /* for reads over a certain size could initiate async read ahead */
4300 rc
= cifs_read(file
, read_data
, PAGE_SIZE
, poffset
);
4305 cifs_dbg(FYI
, "Bytes read %d\n", rc
);
4307 /* we do not want atime to be less than mtime, it broke some apps */
4308 file_inode(file
)->i_atime
= current_time(file_inode(file
));
4309 if (timespec64_compare(&(file_inode(file
)->i_atime
), &(file_inode(file
)->i_mtime
)))
4310 file_inode(file
)->i_atime
= file_inode(file
)->i_mtime
;
4312 file_inode(file
)->i_atime
= current_time(file_inode(file
));
4315 memset(read_data
+ rc
, 0, PAGE_SIZE
- rc
);
4317 flush_dcache_page(page
);
4318 SetPageUptodate(page
);
4320 /* send this page to the cache */
4321 cifs_readpage_to_fscache(file_inode(file
), page
);
4333 static int cifs_readpage(struct file
*file
, struct page
*page
)
4335 loff_t offset
= (loff_t
)page
->index
<< PAGE_SHIFT
;
4341 if (file
->private_data
== NULL
) {
4347 cifs_dbg(FYI
, "readpage %p at offset %d 0x%x\n",
4348 page
, (int)offset
, (int)offset
);
4350 rc
= cifs_readpage_worker(file
, page
, &offset
);
4356 static int is_inode_writable(struct cifsInodeInfo
*cifs_inode
)
4358 struct cifsFileInfo
*open_file
;
4359 struct cifs_tcon
*tcon
=
4360 cifs_sb_master_tcon(CIFS_SB(cifs_inode
->vfs_inode
.i_sb
));
4362 spin_lock(&tcon
->open_file_lock
);
4363 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
4364 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_WRITE
) {
4365 spin_unlock(&tcon
->open_file_lock
);
4369 spin_unlock(&tcon
->open_file_lock
);
4373 /* We do not want to update the file size from server for inodes
4374 open for write - to avoid races with writepage extending
4375 the file - in the future we could consider allowing
4376 refreshing the inode only on increases in the file size
4377 but this is tricky to do without racing with writebehind
4378 page caching in the current Linux kernel design */
4379 bool is_size_safe_to_change(struct cifsInodeInfo
*cifsInode
, __u64 end_of_file
)
4384 if (is_inode_writable(cifsInode
)) {
4385 /* This inode is open for write at least once */
4386 struct cifs_sb_info
*cifs_sb
;
4388 cifs_sb
= CIFS_SB(cifsInode
->vfs_inode
.i_sb
);
4389 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
4390 /* since no page cache to corrupt on directio
4391 we can change size safely */
4395 if (i_size_read(&cifsInode
->vfs_inode
) < end_of_file
)
4403 static int cifs_write_begin(struct file
*file
, struct address_space
*mapping
,
4404 loff_t pos
, unsigned len
, unsigned flags
,
4405 struct page
**pagep
, void **fsdata
)
4408 pgoff_t index
= pos
>> PAGE_SHIFT
;
4409 loff_t offset
= pos
& (PAGE_SIZE
- 1);
4410 loff_t page_start
= pos
& PAGE_MASK
;
4415 cifs_dbg(FYI
, "write_begin from %lld len %d\n", (long long)pos
, len
);
4418 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
4424 if (PageUptodate(page
))
4428 * If we write a full page it will be up to date, no need to read from
4429 * the server. If the write is short, we'll end up doing a sync write
4432 if (len
== PAGE_SIZE
)
4436 * optimize away the read when we have an oplock, and we're not
4437 * expecting to use any of the data we'd be reading in. That
4438 * is, when the page lies beyond the EOF, or straddles the EOF
4439 * and the write will cover all of the existing data.
4441 if (CIFS_CACHE_READ(CIFS_I(mapping
->host
))) {
4442 i_size
= i_size_read(mapping
->host
);
4443 if (page_start
>= i_size
||
4444 (offset
== 0 && (pos
+ len
) >= i_size
)) {
4445 zero_user_segments(page
, 0, offset
,
4449 * PageChecked means that the parts of the page
4450 * to which we're not writing are considered up
4451 * to date. Once the data is copied to the
4452 * page, it can be set uptodate.
4454 SetPageChecked(page
);
4459 if ((file
->f_flags
& O_ACCMODE
) != O_WRONLY
&& !oncethru
) {
4461 * might as well read a page, it is fast enough. If we get
4462 * an error, we don't need to return it. cifs_write_end will
4463 * do a sync write instead since PG_uptodate isn't set.
4465 cifs_readpage_worker(file
, page
, &page_start
);
4470 /* we could try using another file handle if there is one -
4471 but how would we lock it to prevent close of that handle
4472 racing with this read? In any case
4473 this will be written out by write_end so is fine */
4480 static int cifs_release_page(struct page
*page
, gfp_t gfp
)
4482 if (PagePrivate(page
))
4485 return cifs_fscache_release_page(page
, gfp
);
4488 static void cifs_invalidate_page(struct page
*page
, unsigned int offset
,
4489 unsigned int length
)
4491 struct cifsInodeInfo
*cifsi
= CIFS_I(page
->mapping
->host
);
4493 if (offset
== 0 && length
== PAGE_SIZE
)
4494 cifs_fscache_invalidate_page(page
, &cifsi
->vfs_inode
);
4497 static int cifs_launder_page(struct page
*page
)
4500 loff_t range_start
= page_offset(page
);
4501 loff_t range_end
= range_start
+ (loff_t
)(PAGE_SIZE
- 1);
4502 struct writeback_control wbc
= {
4503 .sync_mode
= WB_SYNC_ALL
,
4505 .range_start
= range_start
,
4506 .range_end
= range_end
,
4509 cifs_dbg(FYI
, "Launder page: %p\n", page
);
4511 if (clear_page_dirty_for_io(page
))
4512 rc
= cifs_writepage_locked(page
, &wbc
);
4514 cifs_fscache_invalidate_page(page
, page
->mapping
->host
);
4518 void cifs_oplock_break(struct work_struct
*work
)
4520 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
4522 struct inode
*inode
= d_inode(cfile
->dentry
);
4523 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
4524 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
4525 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
4528 wait_on_bit(&cinode
->flags
, CIFS_INODE_PENDING_WRITERS
,
4529 TASK_UNINTERRUPTIBLE
);
4531 server
->ops
->downgrade_oplock(server
, cinode
,
4532 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2
, &cinode
->flags
));
4534 if (!CIFS_CACHE_WRITE(cinode
) && CIFS_CACHE_READ(cinode
) &&
4535 cifs_has_mand_locks(cinode
)) {
4536 cifs_dbg(FYI
, "Reset oplock to None for inode=%p due to mand locks\n",
4541 if (inode
&& S_ISREG(inode
->i_mode
)) {
4542 if (CIFS_CACHE_READ(cinode
))
4543 break_lease(inode
, O_RDONLY
);
4545 break_lease(inode
, O_WRONLY
);
4546 rc
= filemap_fdatawrite(inode
->i_mapping
);
4547 if (!CIFS_CACHE_READ(cinode
)) {
4548 rc
= filemap_fdatawait(inode
->i_mapping
);
4549 mapping_set_error(inode
->i_mapping
, rc
);
4550 cifs_zap_mapping(inode
);
4552 cifs_dbg(FYI
, "Oplock flush inode %p rc %d\n", inode
, rc
);
4555 rc
= cifs_push_locks(cfile
);
4557 cifs_dbg(VFS
, "Push locks rc = %d\n", rc
);
4560 * releasing stale oplock after recent reconnect of smb session using
4561 * a now incorrect file handle is not a data integrity issue but do
4562 * not bother sending an oplock release if session to server still is
4563 * disconnected since oplock already released by the server
4565 if (!cfile
->oplock_break_cancelled
) {
4566 rc
= tcon
->ses
->server
->ops
->oplock_response(tcon
, &cfile
->fid
,
4568 cifs_dbg(FYI
, "Oplock release rc = %d\n", rc
);
4570 cifs_done_oplock_break(cinode
);
4574 * The presence of cifs_direct_io() in the address space ops vector
4575 * allowes open() O_DIRECT flags which would have failed otherwise.
4577 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
4578 * so this method should never be called.
4580 * Direct IO is not yet supported in the cached mode.
4583 cifs_direct_io(struct kiocb
*iocb
, struct iov_iter
*iter
)
4587 * Eventually need to support direct IO for non forcedirectio mounts
4593 const struct address_space_operations cifs_addr_ops
= {
4594 .readpage
= cifs_readpage
,
4595 .readpages
= cifs_readpages
,
4596 .writepage
= cifs_writepage
,
4597 .writepages
= cifs_writepages
,
4598 .write_begin
= cifs_write_begin
,
4599 .write_end
= cifs_write_end
,
4600 .set_page_dirty
= __set_page_dirty_nobuffers
,
4601 .releasepage
= cifs_release_page
,
4602 .direct_IO
= cifs_direct_io
,
4603 .invalidatepage
= cifs_invalidate_page
,
4604 .launder_page
= cifs_launder_page
,
4608 * cifs_readpages requires the server to support a buffer large enough to
4609 * contain the header plus one complete page of data. Otherwise, we need
4610 * to leave cifs_readpages out of the address space operations.
4612 const struct address_space_operations cifs_addr_ops_smallbuf
= {
4613 .readpage
= cifs_readpage
,
4614 .writepage
= cifs_writepage
,
4615 .writepages
= cifs_writepages
,
4616 .write_begin
= cifs_write_begin
,
4617 .write_end
= cifs_write_end
,
4618 .set_page_dirty
= __set_page_dirty_nobuffers
,
4619 .releasepage
= cifs_release_page
,
4620 .invalidatepage
= cifs_invalidate_page
,
4621 .launder_page
= cifs_launder_page
,