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>
36 #include <asm/div64.h>
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
47 static inline int cifs_convert_flags(unsigned int flags
)
49 if ((flags
& O_ACCMODE
) == O_RDONLY
)
51 else if ((flags
& O_ACCMODE
) == O_WRONLY
)
53 else if ((flags
& O_ACCMODE
) == O_RDWR
) {
54 /* GENERIC_ALL is too much permission to request
55 can cause unnecessary access denied on create */
56 /* return GENERIC_ALL; */
57 return (GENERIC_READ
| GENERIC_WRITE
);
60 return (READ_CONTROL
| FILE_WRITE_ATTRIBUTES
| FILE_READ_ATTRIBUTES
|
61 FILE_WRITE_EA
| FILE_APPEND_DATA
| FILE_WRITE_DATA
|
65 static u32
cifs_posix_convert_flags(unsigned int flags
)
69 if ((flags
& O_ACCMODE
) == O_RDONLY
)
70 posix_flags
= SMB_O_RDONLY
;
71 else if ((flags
& O_ACCMODE
) == O_WRONLY
)
72 posix_flags
= SMB_O_WRONLY
;
73 else if ((flags
& O_ACCMODE
) == O_RDWR
)
74 posix_flags
= SMB_O_RDWR
;
76 if (flags
& O_CREAT
) {
77 posix_flags
|= SMB_O_CREAT
;
79 posix_flags
|= SMB_O_EXCL
;
80 } else if (flags
& O_EXCL
)
81 cifs_dbg(FYI
, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
82 current
->comm
, current
->tgid
);
85 posix_flags
|= SMB_O_TRUNC
;
86 /* be safe and imply O_SYNC for O_DSYNC */
88 posix_flags
|= SMB_O_SYNC
;
89 if (flags
& O_DIRECTORY
)
90 posix_flags
|= SMB_O_DIRECTORY
;
91 if (flags
& O_NOFOLLOW
)
92 posix_flags
|= SMB_O_NOFOLLOW
;
94 posix_flags
|= SMB_O_DIRECT
;
99 static inline int cifs_get_disposition(unsigned int flags
)
101 if ((flags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
103 else if ((flags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
104 return FILE_OVERWRITE_IF
;
105 else if ((flags
& O_CREAT
) == O_CREAT
)
107 else if ((flags
& O_TRUNC
) == O_TRUNC
)
108 return FILE_OVERWRITE
;
113 int cifs_posix_open(char *full_path
, struct inode
**pinode
,
114 struct super_block
*sb
, int mode
, unsigned int f_flags
,
115 __u32
*poplock
, __u16
*pnetfid
, unsigned int xid
)
118 FILE_UNIX_BASIC_INFO
*presp_data
;
119 __u32 posix_flags
= 0;
120 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
121 struct cifs_fattr fattr
;
122 struct tcon_link
*tlink
;
123 struct cifs_tcon
*tcon
;
125 cifs_dbg(FYI
, "posix open %s\n", full_path
);
127 presp_data
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
128 if (presp_data
== NULL
)
131 tlink
= cifs_sb_tlink(cifs_sb
);
137 tcon
= tlink_tcon(tlink
);
138 mode
&= ~current_umask();
140 posix_flags
= cifs_posix_convert_flags(f_flags
);
141 rc
= CIFSPOSIXCreate(xid
, tcon
, posix_flags
, mode
, pnetfid
, presp_data
,
142 poplock
, full_path
, cifs_sb
->local_nls
,
143 cifs_sb
->mnt_cifs_flags
&
144 CIFS_MOUNT_MAP_SPECIAL_CHR
);
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
;
229 oparms
.cifs_sb
= cifs_sb
;
230 oparms
.desired_access
= desired_access
;
231 oparms
.create_options
= create_options
;
232 oparms
.disposition
= disposition
;
233 oparms
.path
= full_path
;
235 oparms
.reconnect
= false;
237 rc
= server
->ops
->open(xid
, &oparms
, oplock
, buf
);
243 rc
= cifs_get_inode_info_unix(&inode
, full_path
, inode
->i_sb
,
246 rc
= cifs_get_inode_info(&inode
, full_path
, buf
, inode
->i_sb
,
255 cifs_has_mand_locks(struct cifsInodeInfo
*cinode
)
257 struct cifs_fid_locks
*cur
;
258 bool has_locks
= false;
260 down_read(&cinode
->lock_sem
);
261 list_for_each_entry(cur
, &cinode
->llist
, llist
) {
262 if (!list_empty(&cur
->locks
)) {
267 up_read(&cinode
->lock_sem
);
271 struct cifsFileInfo
*
272 cifs_new_fileinfo(struct cifs_fid
*fid
, struct file
*file
,
273 struct tcon_link
*tlink
, __u32 oplock
)
275 struct dentry
*dentry
= file
->f_path
.dentry
;
276 struct inode
*inode
= dentry
->d_inode
;
277 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
278 struct cifsFileInfo
*cfile
;
279 struct cifs_fid_locks
*fdlocks
;
280 struct cifs_tcon
*tcon
= tlink_tcon(tlink
);
281 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
283 cfile
= kzalloc(sizeof(struct cifsFileInfo
), GFP_KERNEL
);
287 fdlocks
= kzalloc(sizeof(struct cifs_fid_locks
), GFP_KERNEL
);
293 INIT_LIST_HEAD(&fdlocks
->locks
);
294 fdlocks
->cfile
= cfile
;
295 cfile
->llist
= fdlocks
;
296 down_write(&cinode
->lock_sem
);
297 list_add(&fdlocks
->llist
, &cinode
->llist
);
298 up_write(&cinode
->lock_sem
);
301 cfile
->pid
= current
->tgid
;
302 cfile
->uid
= current_fsuid();
303 cfile
->dentry
= dget(dentry
);
304 cfile
->f_flags
= file
->f_flags
;
305 cfile
->invalidHandle
= false;
306 cfile
->tlink
= cifs_get_tlink(tlink
);
307 INIT_WORK(&cfile
->oplock_break
, cifs_oplock_break
);
308 mutex_init(&cfile
->fh_mutex
);
310 cifs_sb_active(inode
->i_sb
);
313 * If the server returned a read oplock and we have mandatory brlocks,
314 * set oplock level to None.
316 if (server
->ops
->is_read_op(oplock
) && cifs_has_mand_locks(cinode
)) {
317 cifs_dbg(FYI
, "Reset oplock val from read to None due to mand locks\n");
321 spin_lock(&cifs_file_list_lock
);
322 if (fid
->pending_open
->oplock
!= CIFS_OPLOCK_NO_CHANGE
&& oplock
)
323 oplock
= fid
->pending_open
->oplock
;
324 list_del(&fid
->pending_open
->olist
);
326 fid
->purge_cache
= false;
327 server
->ops
->set_fid(cfile
, fid
, oplock
);
329 list_add(&cfile
->tlist
, &tcon
->openFileList
);
330 /* if readable file instance put first in list*/
331 if (file
->f_mode
& FMODE_READ
)
332 list_add(&cfile
->flist
, &cinode
->openFileList
);
334 list_add_tail(&cfile
->flist
, &cinode
->openFileList
);
335 spin_unlock(&cifs_file_list_lock
);
337 if (fid
->purge_cache
)
338 cifs_zap_mapping(inode
);
340 file
->private_data
= cfile
;
344 struct cifsFileInfo
*
345 cifsFileInfo_get(struct cifsFileInfo
*cifs_file
)
347 spin_lock(&cifs_file_list_lock
);
348 cifsFileInfo_get_locked(cifs_file
);
349 spin_unlock(&cifs_file_list_lock
);
354 * Release a reference on the file private data. This may involve closing
355 * the filehandle out on the server. Must be called without holding
356 * cifs_file_list_lock.
358 void cifsFileInfo_put(struct cifsFileInfo
*cifs_file
)
360 struct inode
*inode
= cifs_file
->dentry
->d_inode
;
361 struct cifs_tcon
*tcon
= tlink_tcon(cifs_file
->tlink
);
362 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
363 struct cifsInodeInfo
*cifsi
= CIFS_I(inode
);
364 struct super_block
*sb
= inode
->i_sb
;
365 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
366 struct cifsLockInfo
*li
, *tmp
;
368 struct cifs_pending_open open
;
370 spin_lock(&cifs_file_list_lock
);
371 if (--cifs_file
->count
> 0) {
372 spin_unlock(&cifs_file_list_lock
);
376 if (server
->ops
->get_lease_key
)
377 server
->ops
->get_lease_key(inode
, &fid
);
379 /* store open in pending opens to make sure we don't miss lease break */
380 cifs_add_pending_open_locked(&fid
, cifs_file
->tlink
, &open
);
382 /* remove it from the lists */
383 list_del(&cifs_file
->flist
);
384 list_del(&cifs_file
->tlist
);
386 if (list_empty(&cifsi
->openFileList
)) {
387 cifs_dbg(FYI
, "closing last open instance for inode %p\n",
388 cifs_file
->dentry
->d_inode
);
390 * In strict cache mode we need invalidate mapping on the last
391 * close because it may cause a error when we open this file
392 * again and get at least level II oplock.
394 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_STRICT_IO
)
395 set_bit(CIFS_INO_INVALID_MAPPING
, &cifsi
->flags
);
396 cifs_set_oplock_level(cifsi
, 0);
398 spin_unlock(&cifs_file_list_lock
);
400 cancel_work_sync(&cifs_file
->oplock_break
);
402 if (!tcon
->need_reconnect
&& !cifs_file
->invalidHandle
) {
403 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
407 if (server
->ops
->close
)
408 server
->ops
->close(xid
, tcon
, &cifs_file
->fid
);
412 cifs_del_pending_open(&open
);
415 * Delete any outstanding lock records. We'll lose them when the file
418 down_write(&cifsi
->lock_sem
);
419 list_for_each_entry_safe(li
, tmp
, &cifs_file
->llist
->locks
, llist
) {
420 list_del(&li
->llist
);
421 cifs_del_lock_waiters(li
);
424 list_del(&cifs_file
->llist
->llist
);
425 kfree(cifs_file
->llist
);
426 up_write(&cifsi
->lock_sem
);
428 cifs_put_tlink(cifs_file
->tlink
);
429 dput(cifs_file
->dentry
);
430 cifs_sb_deactive(sb
);
434 int cifs_open(struct inode
*inode
, struct file
*file
)
440 struct cifs_sb_info
*cifs_sb
;
441 struct TCP_Server_Info
*server
;
442 struct cifs_tcon
*tcon
;
443 struct tcon_link
*tlink
;
444 struct cifsFileInfo
*cfile
= NULL
;
445 char *full_path
= NULL
;
446 bool posix_open_ok
= false;
448 struct cifs_pending_open open
;
452 cifs_sb
= CIFS_SB(inode
->i_sb
);
453 tlink
= cifs_sb_tlink(cifs_sb
);
456 return PTR_ERR(tlink
);
458 tcon
= tlink_tcon(tlink
);
459 server
= tcon
->ses
->server
;
461 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
462 if (full_path
== NULL
) {
467 cifs_dbg(FYI
, "inode = 0x%p file flags are 0x%x for %s\n",
468 inode
, file
->f_flags
, full_path
);
475 if (!tcon
->broken_posix_open
&& tcon
->unix_ext
&&
476 cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
477 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
478 /* can not refresh inode info since size could be stale */
479 rc
= cifs_posix_open(full_path
, &inode
, inode
->i_sb
,
480 cifs_sb
->mnt_file_mode
/* ignored */,
481 file
->f_flags
, &oplock
, &fid
.netfid
, xid
);
483 cifs_dbg(FYI
, "posix open succeeded\n");
484 posix_open_ok
= true;
485 } else if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
486 if (tcon
->ses
->serverNOS
)
487 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",
488 tcon
->ses
->serverName
,
489 tcon
->ses
->serverNOS
);
490 tcon
->broken_posix_open
= true;
491 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
492 (rc
!= -EOPNOTSUPP
)) /* path not found or net err */
495 * Else fallthrough to retry open the old way on network i/o
500 if (server
->ops
->get_lease_key
)
501 server
->ops
->get_lease_key(inode
, &fid
);
503 cifs_add_pending_open(&fid
, tlink
, &open
);
505 if (!posix_open_ok
) {
506 if (server
->ops
->get_lease_key
)
507 server
->ops
->get_lease_key(inode
, &fid
);
509 rc
= cifs_nt_open(full_path
, inode
, cifs_sb
, tcon
,
510 file
->f_flags
, &oplock
, &fid
, xid
);
512 cifs_del_pending_open(&open
);
517 cfile
= cifs_new_fileinfo(&fid
, file
, tlink
, oplock
);
519 if (server
->ops
->close
)
520 server
->ops
->close(xid
, tcon
, &fid
);
521 cifs_del_pending_open(&open
);
526 cifs_fscache_set_inode_cookie(inode
, file
);
528 if ((oplock
& CIFS_CREATE_ACTION
) && !posix_open_ok
&& tcon
->unix_ext
) {
530 * Time to set mode which we can not set earlier due to
531 * problems creating new read-only files.
533 struct cifs_unix_set_info_args args
= {
534 .mode
= inode
->i_mode
,
535 .uid
= INVALID_UID
, /* no change */
536 .gid
= INVALID_GID
, /* no change */
537 .ctime
= NO_CHANGE_64
,
538 .atime
= NO_CHANGE_64
,
539 .mtime
= NO_CHANGE_64
,
542 CIFSSMBUnixSetFileInfo(xid
, tcon
, &args
, fid
.netfid
,
549 cifs_put_tlink(tlink
);
553 static int cifs_push_posix_locks(struct cifsFileInfo
*cfile
);
556 * Try to reacquire byte range locks that were released when session
557 * to server was lost.
560 cifs_relock_file(struct cifsFileInfo
*cfile
)
562 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->dentry
->d_sb
);
563 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
564 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
567 down_read(&cinode
->lock_sem
);
568 if (cinode
->can_cache_brlcks
) {
569 /* can cache locks - no need to relock */
570 up_read(&cinode
->lock_sem
);
574 if (cap_unix(tcon
->ses
) &&
575 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
576 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
577 rc
= cifs_push_posix_locks(cfile
);
579 rc
= tcon
->ses
->server
->ops
->push_mand_locks(cfile
);
581 up_read(&cinode
->lock_sem
);
586 cifs_reopen_file(struct cifsFileInfo
*cfile
, bool can_flush
)
591 struct cifs_sb_info
*cifs_sb
;
592 struct cifs_tcon
*tcon
;
593 struct TCP_Server_Info
*server
;
594 struct cifsInodeInfo
*cinode
;
596 char *full_path
= NULL
;
598 int disposition
= FILE_OPEN
;
599 int create_options
= CREATE_NOT_DIR
;
600 struct cifs_open_parms oparms
;
603 mutex_lock(&cfile
->fh_mutex
);
604 if (!cfile
->invalidHandle
) {
605 mutex_unlock(&cfile
->fh_mutex
);
611 inode
= cfile
->dentry
->d_inode
;
612 cifs_sb
= CIFS_SB(inode
->i_sb
);
613 tcon
= tlink_tcon(cfile
->tlink
);
614 server
= tcon
->ses
->server
;
617 * Can not grab rename sem here because various ops, including those
618 * that already have the rename sem can end up causing writepage to get
619 * called and if the server was down that means we end up here, and we
620 * can never tell if the caller already has the rename_sem.
622 full_path
= build_path_from_dentry(cfile
->dentry
);
623 if (full_path
== NULL
) {
625 mutex_unlock(&cfile
->fh_mutex
);
630 cifs_dbg(FYI
, "inode = 0x%p file flags 0x%x for %s\n",
631 inode
, cfile
->f_flags
, full_path
);
633 if (tcon
->ses
->server
->oplocks
)
638 if (tcon
->unix_ext
&& cap_unix(tcon
->ses
) &&
639 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
640 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
642 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
643 * original open. Must mask them off for a reopen.
645 unsigned int oflags
= cfile
->f_flags
&
646 ~(O_CREAT
| O_EXCL
| O_TRUNC
);
648 rc
= cifs_posix_open(full_path
, NULL
, inode
->i_sb
,
649 cifs_sb
->mnt_file_mode
/* ignored */,
650 oflags
, &oplock
, &cfile
->fid
.netfid
, xid
);
652 cifs_dbg(FYI
, "posix reopen succeeded\n");
653 oparms
.reconnect
= true;
657 * fallthrough to retry open the old way on errors, especially
658 * in the reconnect path it is important to retry hard
662 desired_access
= cifs_convert_flags(cfile
->f_flags
);
664 if (backup_cred(cifs_sb
))
665 create_options
|= CREATE_OPEN_BACKUP_INTENT
;
667 if (server
->ops
->get_lease_key
)
668 server
->ops
->get_lease_key(inode
, &cfile
->fid
);
671 oparms
.cifs_sb
= cifs_sb
;
672 oparms
.desired_access
= desired_access
;
673 oparms
.create_options
= create_options
;
674 oparms
.disposition
= disposition
;
675 oparms
.path
= full_path
;
676 oparms
.fid
= &cfile
->fid
;
677 oparms
.reconnect
= true;
680 * Can not refresh inode by passing in file_info buf to be returned by
681 * ops->open and then calling get_inode_info with returned buf since
682 * file might have write behind data that needs to be flushed and server
683 * version of file size can be stale. If we knew for sure that inode was
684 * not dirty locally we could do this.
686 rc
= server
->ops
->open(xid
, &oparms
, &oplock
, NULL
);
687 if (rc
== -ENOENT
&& oparms
.reconnect
== false) {
688 /* durable handle timeout is expired - open the file again */
689 rc
= server
->ops
->open(xid
, &oparms
, &oplock
, NULL
);
690 /* indicate that we need to relock the file */
691 oparms
.reconnect
= true;
695 mutex_unlock(&cfile
->fh_mutex
);
696 cifs_dbg(FYI
, "cifs_reopen returned 0x%x\n", rc
);
697 cifs_dbg(FYI
, "oplock: %d\n", oplock
);
698 goto reopen_error_exit
;
702 cfile
->invalidHandle
= false;
703 mutex_unlock(&cfile
->fh_mutex
);
704 cinode
= CIFS_I(inode
);
707 rc
= filemap_write_and_wait(inode
->i_mapping
);
708 mapping_set_error(inode
->i_mapping
, rc
);
711 rc
= cifs_get_inode_info_unix(&inode
, full_path
,
714 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
,
715 inode
->i_sb
, xid
, NULL
);
718 * Else we are writing out data to server already and could deadlock if
719 * we tried to flush data, and since we do not know if we have data that
720 * would invalidate the current end of file on the server we can not go
721 * to the server to get the new inode info.
724 server
->ops
->set_fid(cfile
, &cfile
->fid
, oplock
);
725 if (oparms
.reconnect
)
726 cifs_relock_file(cfile
);
734 int cifs_close(struct inode
*inode
, struct file
*file
)
736 if (file
->private_data
!= NULL
) {
737 cifsFileInfo_put(file
->private_data
);
738 file
->private_data
= NULL
;
741 /* return code from the ->release op is always ignored */
745 int cifs_closedir(struct inode
*inode
, struct file
*file
)
749 struct cifsFileInfo
*cfile
= file
->private_data
;
750 struct cifs_tcon
*tcon
;
751 struct TCP_Server_Info
*server
;
754 cifs_dbg(FYI
, "Closedir inode = 0x%p\n", inode
);
760 tcon
= tlink_tcon(cfile
->tlink
);
761 server
= tcon
->ses
->server
;
763 cifs_dbg(FYI
, "Freeing private data in close dir\n");
764 spin_lock(&cifs_file_list_lock
);
765 if (!cfile
->srch_inf
.endOfSearch
&& !cfile
->invalidHandle
) {
766 cfile
->invalidHandle
= true;
767 spin_unlock(&cifs_file_list_lock
);
768 if (server
->ops
->close_dir
)
769 rc
= server
->ops
->close_dir(xid
, tcon
, &cfile
->fid
);
772 cifs_dbg(FYI
, "Closing uncompleted readdir with rc %d\n", rc
);
773 /* not much we can do if it fails anyway, ignore rc */
776 spin_unlock(&cifs_file_list_lock
);
778 buf
= cfile
->srch_inf
.ntwrk_buf_start
;
780 cifs_dbg(FYI
, "closedir free smb buf in srch struct\n");
781 cfile
->srch_inf
.ntwrk_buf_start
= NULL
;
782 if (cfile
->srch_inf
.smallBuf
)
783 cifs_small_buf_release(buf
);
785 cifs_buf_release(buf
);
788 cifs_put_tlink(cfile
->tlink
);
789 kfree(file
->private_data
);
790 file
->private_data
= NULL
;
791 /* BB can we lock the filestruct while this is going on? */
796 static struct cifsLockInfo
*
797 cifs_lock_init(__u64 offset
, __u64 length
, __u8 type
)
799 struct cifsLockInfo
*lock
=
800 kmalloc(sizeof(struct cifsLockInfo
), GFP_KERNEL
);
803 lock
->offset
= offset
;
804 lock
->length
= length
;
806 lock
->pid
= current
->tgid
;
807 INIT_LIST_HEAD(&lock
->blist
);
808 init_waitqueue_head(&lock
->block_q
);
813 cifs_del_lock_waiters(struct cifsLockInfo
*lock
)
815 struct cifsLockInfo
*li
, *tmp
;
816 list_for_each_entry_safe(li
, tmp
, &lock
->blist
, blist
) {
817 list_del_init(&li
->blist
);
818 wake_up(&li
->block_q
);
822 #define CIFS_LOCK_OP 0
823 #define CIFS_READ_OP 1
824 #define CIFS_WRITE_OP 2
826 /* @rw_check : 0 - no op, 1 - read, 2 - write */
828 cifs_find_fid_lock_conflict(struct cifs_fid_locks
*fdlocks
, __u64 offset
,
829 __u64 length
, __u8 type
, struct cifsFileInfo
*cfile
,
830 struct cifsLockInfo
**conf_lock
, int rw_check
)
832 struct cifsLockInfo
*li
;
833 struct cifsFileInfo
*cur_cfile
= fdlocks
->cfile
;
834 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
836 list_for_each_entry(li
, &fdlocks
->locks
, llist
) {
837 if (offset
+ length
<= li
->offset
||
838 offset
>= li
->offset
+ li
->length
)
840 if (rw_check
!= CIFS_LOCK_OP
&& current
->tgid
== li
->pid
&&
841 server
->ops
->compare_fids(cfile
, cur_cfile
)) {
842 /* shared lock prevents write op through the same fid */
843 if (!(li
->type
& server
->vals
->shared_lock_type
) ||
844 rw_check
!= CIFS_WRITE_OP
)
847 if ((type
& server
->vals
->shared_lock_type
) &&
848 ((server
->ops
->compare_fids(cfile
, cur_cfile
) &&
849 current
->tgid
== li
->pid
) || type
== li
->type
))
859 cifs_find_lock_conflict(struct cifsFileInfo
*cfile
, __u64 offset
, __u64 length
,
860 __u8 type
, struct cifsLockInfo
**conf_lock
,
864 struct cifs_fid_locks
*cur
;
865 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
867 list_for_each_entry(cur
, &cinode
->llist
, llist
) {
868 rc
= cifs_find_fid_lock_conflict(cur
, offset
, length
, type
,
869 cfile
, conf_lock
, rw_check
);
878 * Check if there is another lock that prevents us to set the lock (mandatory
879 * style). If such a lock exists, update the flock structure with its
880 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
881 * or leave it the same if we can't. Returns 0 if we don't need to request to
882 * the server or 1 otherwise.
885 cifs_lock_test(struct cifsFileInfo
*cfile
, __u64 offset
, __u64 length
,
886 __u8 type
, struct file_lock
*flock
)
889 struct cifsLockInfo
*conf_lock
;
890 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
891 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
894 down_read(&cinode
->lock_sem
);
896 exist
= cifs_find_lock_conflict(cfile
, offset
, length
, type
,
897 &conf_lock
, CIFS_LOCK_OP
);
899 flock
->fl_start
= conf_lock
->offset
;
900 flock
->fl_end
= conf_lock
->offset
+ conf_lock
->length
- 1;
901 flock
->fl_pid
= conf_lock
->pid
;
902 if (conf_lock
->type
& server
->vals
->shared_lock_type
)
903 flock
->fl_type
= F_RDLCK
;
905 flock
->fl_type
= F_WRLCK
;
906 } else if (!cinode
->can_cache_brlcks
)
909 flock
->fl_type
= F_UNLCK
;
911 up_read(&cinode
->lock_sem
);
916 cifs_lock_add(struct cifsFileInfo
*cfile
, struct cifsLockInfo
*lock
)
918 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
919 down_write(&cinode
->lock_sem
);
920 list_add_tail(&lock
->llist
, &cfile
->llist
->locks
);
921 up_write(&cinode
->lock_sem
);
925 * Set the byte-range lock (mandatory style). Returns:
926 * 1) 0, if we set the lock and don't need to request to the server;
927 * 2) 1, if no locks prevent us but we need to request to the server;
928 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
931 cifs_lock_add_if(struct cifsFileInfo
*cfile
, struct cifsLockInfo
*lock
,
934 struct cifsLockInfo
*conf_lock
;
935 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
941 down_write(&cinode
->lock_sem
);
943 exist
= cifs_find_lock_conflict(cfile
, lock
->offset
, lock
->length
,
944 lock
->type
, &conf_lock
, CIFS_LOCK_OP
);
945 if (!exist
&& cinode
->can_cache_brlcks
) {
946 list_add_tail(&lock
->llist
, &cfile
->llist
->locks
);
947 up_write(&cinode
->lock_sem
);
956 list_add_tail(&lock
->blist
, &conf_lock
->blist
);
957 up_write(&cinode
->lock_sem
);
958 rc
= wait_event_interruptible(lock
->block_q
,
959 (lock
->blist
.prev
== &lock
->blist
) &&
960 (lock
->blist
.next
== &lock
->blist
));
963 down_write(&cinode
->lock_sem
);
964 list_del_init(&lock
->blist
);
967 up_write(&cinode
->lock_sem
);
972 * Check if there is another lock that prevents us to set the lock (posix
973 * style). If such a lock exists, update the flock structure with its
974 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
975 * or leave it the same if we can't. Returns 0 if we don't need to request to
976 * the server or 1 otherwise.
979 cifs_posix_lock_test(struct file
*file
, struct file_lock
*flock
)
982 struct cifsInodeInfo
*cinode
= CIFS_I(file_inode(file
));
983 unsigned char saved_type
= flock
->fl_type
;
985 if ((flock
->fl_flags
& FL_POSIX
) == 0)
988 down_read(&cinode
->lock_sem
);
989 posix_test_lock(file
, flock
);
991 if (flock
->fl_type
== F_UNLCK
&& !cinode
->can_cache_brlcks
) {
992 flock
->fl_type
= saved_type
;
996 up_read(&cinode
->lock_sem
);
1001 * Set the byte-range lock (posix style). Returns:
1002 * 1) 0, if we set the lock and don't need to request to the server;
1003 * 2) 1, if we need to request to the server;
1004 * 3) <0, if the error occurs while setting the lock.
1007 cifs_posix_lock_set(struct file
*file
, struct file_lock
*flock
)
1009 struct cifsInodeInfo
*cinode
= CIFS_I(file_inode(file
));
1012 if ((flock
->fl_flags
& FL_POSIX
) == 0)
1016 down_write(&cinode
->lock_sem
);
1017 if (!cinode
->can_cache_brlcks
) {
1018 up_write(&cinode
->lock_sem
);
1022 rc
= posix_lock_file(file
, flock
, NULL
);
1023 up_write(&cinode
->lock_sem
);
1024 if (rc
== FILE_LOCK_DEFERRED
) {
1025 rc
= wait_event_interruptible(flock
->fl_wait
, !flock
->fl_next
);
1028 posix_unblock_lock(flock
);
1034 cifs_push_mandatory_locks(struct cifsFileInfo
*cfile
)
1037 int rc
= 0, stored_rc
;
1038 struct cifsLockInfo
*li
, *tmp
;
1039 struct cifs_tcon
*tcon
;
1040 unsigned int num
, max_num
, max_buf
;
1041 LOCKING_ANDX_RANGE
*buf
, *cur
;
1042 int types
[] = {LOCKING_ANDX_LARGE_FILES
,
1043 LOCKING_ANDX_SHARED_LOCK
| LOCKING_ANDX_LARGE_FILES
};
1047 tcon
= tlink_tcon(cfile
->tlink
);
1050 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1051 * and check it for zero before using.
1053 max_buf
= tcon
->ses
->server
->maxBuf
;
1059 max_num
= (max_buf
- sizeof(struct smb_hdr
)) /
1060 sizeof(LOCKING_ANDX_RANGE
);
1061 buf
= kzalloc(max_num
* sizeof(LOCKING_ANDX_RANGE
), GFP_KERNEL
);
1067 for (i
= 0; i
< 2; i
++) {
1070 list_for_each_entry_safe(li
, tmp
, &cfile
->llist
->locks
, llist
) {
1071 if (li
->type
!= types
[i
])
1073 cur
->Pid
= cpu_to_le16(li
->pid
);
1074 cur
->LengthLow
= cpu_to_le32((u32
)li
->length
);
1075 cur
->LengthHigh
= cpu_to_le32((u32
)(li
->length
>>32));
1076 cur
->OffsetLow
= cpu_to_le32((u32
)li
->offset
);
1077 cur
->OffsetHigh
= cpu_to_le32((u32
)(li
->offset
>>32));
1078 if (++num
== max_num
) {
1079 stored_rc
= cifs_lockv(xid
, tcon
,
1081 (__u8
)li
->type
, 0, num
,
1092 stored_rc
= cifs_lockv(xid
, tcon
, cfile
->fid
.netfid
,
1093 (__u8
)types
[i
], 0, num
, buf
);
1104 /* copied from fs/locks.c with a name change */
1105 #define cifs_for_each_lock(inode, lockp) \
1106 for (lockp = &inode->i_flock; *lockp != NULL; \
1107 lockp = &(*lockp)->fl_next)
1109 struct lock_to_push
{
1110 struct list_head llist
;
1119 cifs_push_posix_locks(struct cifsFileInfo
*cfile
)
1121 struct inode
*inode
= cfile
->dentry
->d_inode
;
1122 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1123 struct file_lock
*flock
, **before
;
1124 unsigned int count
= 0, i
= 0;
1125 int rc
= 0, xid
, type
;
1126 struct list_head locks_to_send
, *el
;
1127 struct lock_to_push
*lck
, *tmp
;
1132 spin_lock(&inode
->i_lock
);
1133 cifs_for_each_lock(inode
, before
) {
1134 if ((*before
)->fl_flags
& FL_POSIX
)
1137 spin_unlock(&inode
->i_lock
);
1139 INIT_LIST_HEAD(&locks_to_send
);
1142 * Allocating count locks is enough because no FL_POSIX locks can be
1143 * added to the list while we are holding cinode->lock_sem that
1144 * protects locking operations of this inode.
1146 for (; i
< count
; i
++) {
1147 lck
= kmalloc(sizeof(struct lock_to_push
), GFP_KERNEL
);
1152 list_add_tail(&lck
->llist
, &locks_to_send
);
1155 el
= locks_to_send
.next
;
1156 spin_lock(&inode
->i_lock
);
1157 cifs_for_each_lock(inode
, before
) {
1159 if ((flock
->fl_flags
& FL_POSIX
) == 0)
1161 if (el
== &locks_to_send
) {
1163 * The list ended. We don't have enough allocated
1164 * structures - something is really wrong.
1166 cifs_dbg(VFS
, "Can't push all brlocks!\n");
1169 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1170 if (flock
->fl_type
== F_RDLCK
|| flock
->fl_type
== F_SHLCK
)
1174 lck
= list_entry(el
, struct lock_to_push
, llist
);
1175 lck
->pid
= flock
->fl_pid
;
1176 lck
->netfid
= cfile
->fid
.netfid
;
1177 lck
->length
= length
;
1179 lck
->offset
= flock
->fl_start
;
1182 spin_unlock(&inode
->i_lock
);
1184 list_for_each_entry_safe(lck
, tmp
, &locks_to_send
, llist
) {
1187 stored_rc
= CIFSSMBPosixLock(xid
, tcon
, lck
->netfid
, lck
->pid
,
1188 lck
->offset
, lck
->length
, NULL
,
1192 list_del(&lck
->llist
);
1200 list_for_each_entry_safe(lck
, tmp
, &locks_to_send
, llist
) {
1201 list_del(&lck
->llist
);
1208 cifs_push_locks(struct cifsFileInfo
*cfile
)
1210 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->dentry
->d_sb
);
1211 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
1212 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1215 /* we are going to update can_cache_brlcks here - need a write access */
1216 down_write(&cinode
->lock_sem
);
1217 if (!cinode
->can_cache_brlcks
) {
1218 up_write(&cinode
->lock_sem
);
1222 if (cap_unix(tcon
->ses
) &&
1223 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
1224 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
1225 rc
= cifs_push_posix_locks(cfile
);
1227 rc
= tcon
->ses
->server
->ops
->push_mand_locks(cfile
);
1229 cinode
->can_cache_brlcks
= false;
1230 up_write(&cinode
->lock_sem
);
1235 cifs_read_flock(struct file_lock
*flock
, __u32
*type
, int *lock
, int *unlock
,
1236 bool *wait_flag
, struct TCP_Server_Info
*server
)
1238 if (flock
->fl_flags
& FL_POSIX
)
1239 cifs_dbg(FYI
, "Posix\n");
1240 if (flock
->fl_flags
& FL_FLOCK
)
1241 cifs_dbg(FYI
, "Flock\n");
1242 if (flock
->fl_flags
& FL_SLEEP
) {
1243 cifs_dbg(FYI
, "Blocking lock\n");
1246 if (flock
->fl_flags
& FL_ACCESS
)
1247 cifs_dbg(FYI
, "Process suspended by mandatory locking - not implemented yet\n");
1248 if (flock
->fl_flags
& FL_LEASE
)
1249 cifs_dbg(FYI
, "Lease on file - not implemented yet\n");
1250 if (flock
->fl_flags
&
1251 (~(FL_POSIX
| FL_FLOCK
| FL_SLEEP
|
1252 FL_ACCESS
| FL_LEASE
| FL_CLOSE
)))
1253 cifs_dbg(FYI
, "Unknown lock flags 0x%x\n", flock
->fl_flags
);
1255 *type
= server
->vals
->large_lock_type
;
1256 if (flock
->fl_type
== F_WRLCK
) {
1257 cifs_dbg(FYI
, "F_WRLCK\n");
1258 *type
|= server
->vals
->exclusive_lock_type
;
1260 } else if (flock
->fl_type
== F_UNLCK
) {
1261 cifs_dbg(FYI
, "F_UNLCK\n");
1262 *type
|= server
->vals
->unlock_lock_type
;
1264 /* Check if unlock includes more than one lock range */
1265 } else if (flock
->fl_type
== F_RDLCK
) {
1266 cifs_dbg(FYI
, "F_RDLCK\n");
1267 *type
|= server
->vals
->shared_lock_type
;
1269 } else if (flock
->fl_type
== F_EXLCK
) {
1270 cifs_dbg(FYI
, "F_EXLCK\n");
1271 *type
|= server
->vals
->exclusive_lock_type
;
1273 } else if (flock
->fl_type
== F_SHLCK
) {
1274 cifs_dbg(FYI
, "F_SHLCK\n");
1275 *type
|= server
->vals
->shared_lock_type
;
1278 cifs_dbg(FYI
, "Unknown type of lock\n");
1282 cifs_getlk(struct file
*file
, struct file_lock
*flock
, __u32 type
,
1283 bool wait_flag
, bool posix_lck
, unsigned int xid
)
1286 __u64 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1287 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)file
->private_data
;
1288 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1289 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1290 __u16 netfid
= cfile
->fid
.netfid
;
1293 int posix_lock_type
;
1295 rc
= cifs_posix_lock_test(file
, flock
);
1299 if (type
& server
->vals
->shared_lock_type
)
1300 posix_lock_type
= CIFS_RDLCK
;
1302 posix_lock_type
= CIFS_WRLCK
;
1303 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, current
->tgid
,
1304 flock
->fl_start
, length
, flock
,
1305 posix_lock_type
, wait_flag
);
1309 rc
= cifs_lock_test(cfile
, flock
->fl_start
, length
, type
, flock
);
1313 /* BB we could chain these into one lock request BB */
1314 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
, type
,
1317 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
,
1319 flock
->fl_type
= F_UNLCK
;
1321 cifs_dbg(VFS
, "Error unlocking previously locked range %d during test of lock\n",
1326 if (type
& server
->vals
->shared_lock_type
) {
1327 flock
->fl_type
= F_WRLCK
;
1331 type
&= ~server
->vals
->exclusive_lock_type
;
1333 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
,
1334 type
| server
->vals
->shared_lock_type
,
1337 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
,
1338 type
| server
->vals
->shared_lock_type
, 0, 1, false);
1339 flock
->fl_type
= F_RDLCK
;
1341 cifs_dbg(VFS
, "Error unlocking previously locked range %d during test of lock\n",
1344 flock
->fl_type
= F_WRLCK
;
1350 cifs_move_llist(struct list_head
*source
, struct list_head
*dest
)
1352 struct list_head
*li
, *tmp
;
1353 list_for_each_safe(li
, tmp
, source
)
1354 list_move(li
, dest
);
1358 cifs_free_llist(struct list_head
*llist
)
1360 struct cifsLockInfo
*li
, *tmp
;
1361 list_for_each_entry_safe(li
, tmp
, llist
, llist
) {
1362 cifs_del_lock_waiters(li
);
1363 list_del(&li
->llist
);
1369 cifs_unlock_range(struct cifsFileInfo
*cfile
, struct file_lock
*flock
,
1372 int rc
= 0, stored_rc
;
1373 int types
[] = {LOCKING_ANDX_LARGE_FILES
,
1374 LOCKING_ANDX_SHARED_LOCK
| LOCKING_ANDX_LARGE_FILES
};
1376 unsigned int max_num
, num
, max_buf
;
1377 LOCKING_ANDX_RANGE
*buf
, *cur
;
1378 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1379 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
1380 struct cifsLockInfo
*li
, *tmp
;
1381 __u64 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1382 struct list_head tmp_llist
;
1384 INIT_LIST_HEAD(&tmp_llist
);
1387 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1388 * and check it for zero before using.
1390 max_buf
= tcon
->ses
->server
->maxBuf
;
1394 max_num
= (max_buf
- sizeof(struct smb_hdr
)) /
1395 sizeof(LOCKING_ANDX_RANGE
);
1396 buf
= kzalloc(max_num
* sizeof(LOCKING_ANDX_RANGE
), GFP_KERNEL
);
1400 down_write(&cinode
->lock_sem
);
1401 for (i
= 0; i
< 2; i
++) {
1404 list_for_each_entry_safe(li
, tmp
, &cfile
->llist
->locks
, llist
) {
1405 if (flock
->fl_start
> li
->offset
||
1406 (flock
->fl_start
+ length
) <
1407 (li
->offset
+ li
->length
))
1409 if (current
->tgid
!= li
->pid
)
1411 if (types
[i
] != li
->type
)
1413 if (cinode
->can_cache_brlcks
) {
1415 * We can cache brlock requests - simply remove
1416 * a lock from the file's list.
1418 list_del(&li
->llist
);
1419 cifs_del_lock_waiters(li
);
1423 cur
->Pid
= cpu_to_le16(li
->pid
);
1424 cur
->LengthLow
= cpu_to_le32((u32
)li
->length
);
1425 cur
->LengthHigh
= cpu_to_le32((u32
)(li
->length
>>32));
1426 cur
->OffsetLow
= cpu_to_le32((u32
)li
->offset
);
1427 cur
->OffsetHigh
= cpu_to_le32((u32
)(li
->offset
>>32));
1429 * We need to save a lock here to let us add it again to
1430 * the file's list if the unlock range request fails on
1433 list_move(&li
->llist
, &tmp_llist
);
1434 if (++num
== max_num
) {
1435 stored_rc
= cifs_lockv(xid
, tcon
,
1437 li
->type
, num
, 0, buf
);
1440 * We failed on the unlock range
1441 * request - add all locks from the tmp
1442 * list to the head of the file's list.
1444 cifs_move_llist(&tmp_llist
,
1445 &cfile
->llist
->locks
);
1449 * The unlock range request succeed -
1450 * free the tmp list.
1452 cifs_free_llist(&tmp_llist
);
1459 stored_rc
= cifs_lockv(xid
, tcon
, cfile
->fid
.netfid
,
1460 types
[i
], num
, 0, buf
);
1462 cifs_move_llist(&tmp_llist
,
1463 &cfile
->llist
->locks
);
1466 cifs_free_llist(&tmp_llist
);
1470 up_write(&cinode
->lock_sem
);
1476 cifs_setlk(struct file
*file
, struct file_lock
*flock
, __u32 type
,
1477 bool wait_flag
, bool posix_lck
, int lock
, int unlock
,
1481 __u64 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1482 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)file
->private_data
;
1483 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1484 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1485 struct inode
*inode
= cfile
->dentry
->d_inode
;
1488 int posix_lock_type
;
1490 rc
= cifs_posix_lock_set(file
, flock
);
1494 if (type
& server
->vals
->shared_lock_type
)
1495 posix_lock_type
= CIFS_RDLCK
;
1497 posix_lock_type
= CIFS_WRLCK
;
1500 posix_lock_type
= CIFS_UNLCK
;
1502 rc
= CIFSSMBPosixLock(xid
, tcon
, cfile
->fid
.netfid
,
1503 current
->tgid
, flock
->fl_start
, length
,
1504 NULL
, posix_lock_type
, wait_flag
);
1509 struct cifsLockInfo
*lock
;
1511 lock
= cifs_lock_init(flock
->fl_start
, length
, type
);
1515 rc
= cifs_lock_add_if(cfile
, lock
, wait_flag
);
1524 * Windows 7 server can delay breaking lease from read to None
1525 * if we set a byte-range lock on a file - break it explicitly
1526 * before sending the lock to the server to be sure the next
1527 * read won't conflict with non-overlapted locks due to
1530 if (!CIFS_CACHE_WRITE(CIFS_I(inode
)) &&
1531 CIFS_CACHE_READ(CIFS_I(inode
))) {
1532 cifs_zap_mapping(inode
);
1533 cifs_dbg(FYI
, "Set no oplock for inode=%p due to mand locks\n",
1535 CIFS_I(inode
)->oplock
= 0;
1538 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
,
1539 type
, 1, 0, wait_flag
);
1545 cifs_lock_add(cfile
, lock
);
1547 rc
= server
->ops
->mand_unlock_range(cfile
, flock
, xid
);
1550 if (flock
->fl_flags
& FL_POSIX
)
1551 posix_lock_file_wait(file
, flock
);
1555 int cifs_lock(struct file
*file
, int cmd
, struct file_lock
*flock
)
1558 int lock
= 0, unlock
= 0;
1559 bool wait_flag
= false;
1560 bool posix_lck
= false;
1561 struct cifs_sb_info
*cifs_sb
;
1562 struct cifs_tcon
*tcon
;
1563 struct cifsInodeInfo
*cinode
;
1564 struct cifsFileInfo
*cfile
;
1571 cifs_dbg(FYI
, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1572 cmd
, flock
->fl_flags
, flock
->fl_type
,
1573 flock
->fl_start
, flock
->fl_end
);
1575 cfile
= (struct cifsFileInfo
*)file
->private_data
;
1576 tcon
= tlink_tcon(cfile
->tlink
);
1578 cifs_read_flock(flock
, &type
, &lock
, &unlock
, &wait_flag
,
1581 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1582 netfid
= cfile
->fid
.netfid
;
1583 cinode
= CIFS_I(file_inode(file
));
1585 if (cap_unix(tcon
->ses
) &&
1586 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
1587 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
1590 * BB add code here to normalize offset and length to account for
1591 * negative length which we can not accept over the wire.
1593 if (IS_GETLK(cmd
)) {
1594 rc
= cifs_getlk(file
, flock
, type
, wait_flag
, posix_lck
, xid
);
1599 if (!lock
&& !unlock
) {
1601 * if no lock or unlock then nothing to do since we do not
1608 rc
= cifs_setlk(file
, flock
, type
, wait_flag
, posix_lck
, lock
, unlock
,
1615 * update the file size (if needed) after a write. Should be called with
1616 * the inode->i_lock held
1619 cifs_update_eof(struct cifsInodeInfo
*cifsi
, loff_t offset
,
1620 unsigned int bytes_written
)
1622 loff_t end_of_write
= offset
+ bytes_written
;
1624 if (end_of_write
> cifsi
->server_eof
)
1625 cifsi
->server_eof
= end_of_write
;
1629 cifs_write(struct cifsFileInfo
*open_file
, __u32 pid
, const char *write_data
,
1630 size_t write_size
, loff_t
*offset
)
1633 unsigned int bytes_written
= 0;
1634 unsigned int total_written
;
1635 struct cifs_sb_info
*cifs_sb
;
1636 struct cifs_tcon
*tcon
;
1637 struct TCP_Server_Info
*server
;
1639 struct dentry
*dentry
= open_file
->dentry
;
1640 struct cifsInodeInfo
*cifsi
= CIFS_I(dentry
->d_inode
);
1641 struct cifs_io_parms io_parms
;
1643 cifs_sb
= CIFS_SB(dentry
->d_sb
);
1645 cifs_dbg(FYI
, "write %zd bytes to offset %lld of %s\n",
1646 write_size
, *offset
, dentry
->d_name
.name
);
1648 tcon
= tlink_tcon(open_file
->tlink
);
1649 server
= tcon
->ses
->server
;
1651 if (!server
->ops
->sync_write
)
1656 for (total_written
= 0; write_size
> total_written
;
1657 total_written
+= bytes_written
) {
1659 while (rc
== -EAGAIN
) {
1663 if (open_file
->invalidHandle
) {
1664 /* we could deadlock if we called
1665 filemap_fdatawait from here so tell
1666 reopen_file not to flush data to
1668 rc
= cifs_reopen_file(open_file
, false);
1673 len
= min((size_t)cifs_sb
->wsize
,
1674 write_size
- total_written
);
1675 /* iov[0] is reserved for smb header */
1676 iov
[1].iov_base
= (char *)write_data
+ total_written
;
1677 iov
[1].iov_len
= len
;
1679 io_parms
.tcon
= tcon
;
1680 io_parms
.offset
= *offset
;
1681 io_parms
.length
= len
;
1682 rc
= server
->ops
->sync_write(xid
, open_file
, &io_parms
,
1683 &bytes_written
, iov
, 1);
1685 if (rc
|| (bytes_written
== 0)) {
1693 spin_lock(&dentry
->d_inode
->i_lock
);
1694 cifs_update_eof(cifsi
, *offset
, bytes_written
);
1695 spin_unlock(&dentry
->d_inode
->i_lock
);
1696 *offset
+= bytes_written
;
1700 cifs_stats_bytes_written(tcon
, total_written
);
1702 if (total_written
> 0) {
1703 spin_lock(&dentry
->d_inode
->i_lock
);
1704 if (*offset
> dentry
->d_inode
->i_size
)
1705 i_size_write(dentry
->d_inode
, *offset
);
1706 spin_unlock(&dentry
->d_inode
->i_lock
);
1708 mark_inode_dirty_sync(dentry
->d_inode
);
1710 return total_written
;
1713 struct cifsFileInfo
*find_readable_file(struct cifsInodeInfo
*cifs_inode
,
1716 struct cifsFileInfo
*open_file
= NULL
;
1717 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1719 /* only filter by fsuid on multiuser mounts */
1720 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1723 spin_lock(&cifs_file_list_lock
);
1724 /* we could simply get the first_list_entry since write-only entries
1725 are always at the end of the list but since the first entry might
1726 have a close pending, we go through the whole list */
1727 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1728 if (fsuid_only
&& !uid_eq(open_file
->uid
, current_fsuid()))
1730 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_READ
) {
1731 if (!open_file
->invalidHandle
) {
1732 /* found a good file */
1733 /* lock it so it will not be closed on us */
1734 cifsFileInfo_get_locked(open_file
);
1735 spin_unlock(&cifs_file_list_lock
);
1737 } /* else might as well continue, and look for
1738 another, or simply have the caller reopen it
1739 again rather than trying to fix this handle */
1740 } else /* write only file */
1741 break; /* write only files are last so must be done */
1743 spin_unlock(&cifs_file_list_lock
);
1747 struct cifsFileInfo
*find_writable_file(struct cifsInodeInfo
*cifs_inode
,
1750 struct cifsFileInfo
*open_file
, *inv_file
= NULL
;
1751 struct cifs_sb_info
*cifs_sb
;
1752 bool any_available
= false;
1754 unsigned int refind
= 0;
1756 /* Having a null inode here (because mapping->host was set to zero by
1757 the VFS or MM) should not happen but we had reports of on oops (due to
1758 it being zero) during stress testcases so we need to check for it */
1760 if (cifs_inode
== NULL
) {
1761 cifs_dbg(VFS
, "Null inode passed to cifs_writeable_file\n");
1766 cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1768 /* only filter by fsuid on multiuser mounts */
1769 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1772 spin_lock(&cifs_file_list_lock
);
1774 if (refind
> MAX_REOPEN_ATT
) {
1775 spin_unlock(&cifs_file_list_lock
);
1778 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1779 if (!any_available
&& open_file
->pid
!= current
->tgid
)
1781 if (fsuid_only
&& !uid_eq(open_file
->uid
, current_fsuid()))
1783 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_WRITE
) {
1784 if (!open_file
->invalidHandle
) {
1785 /* found a good writable file */
1786 cifsFileInfo_get_locked(open_file
);
1787 spin_unlock(&cifs_file_list_lock
);
1791 inv_file
= open_file
;
1795 /* couldn't find useable FH with same pid, try any available */
1796 if (!any_available
) {
1797 any_available
= true;
1798 goto refind_writable
;
1802 any_available
= false;
1803 cifsFileInfo_get_locked(inv_file
);
1806 spin_unlock(&cifs_file_list_lock
);
1809 rc
= cifs_reopen_file(inv_file
, false);
1813 spin_lock(&cifs_file_list_lock
);
1814 list_move_tail(&inv_file
->flist
,
1815 &cifs_inode
->openFileList
);
1816 spin_unlock(&cifs_file_list_lock
);
1817 cifsFileInfo_put(inv_file
);
1818 spin_lock(&cifs_file_list_lock
);
1820 goto refind_writable
;
1827 static int cifs_partialpagewrite(struct page
*page
, unsigned from
, unsigned to
)
1829 struct address_space
*mapping
= page
->mapping
;
1830 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1833 int bytes_written
= 0;
1834 struct inode
*inode
;
1835 struct cifsFileInfo
*open_file
;
1837 if (!mapping
|| !mapping
->host
)
1840 inode
= page
->mapping
->host
;
1842 offset
+= (loff_t
)from
;
1843 write_data
= kmap(page
);
1846 if ((to
> PAGE_CACHE_SIZE
) || (from
> to
)) {
1851 /* racing with truncate? */
1852 if (offset
> mapping
->host
->i_size
) {
1854 return 0; /* don't care */
1857 /* check to make sure that we are not extending the file */
1858 if (mapping
->host
->i_size
- offset
< (loff_t
)to
)
1859 to
= (unsigned)(mapping
->host
->i_size
- offset
);
1861 open_file
= find_writable_file(CIFS_I(mapping
->host
), false);
1863 bytes_written
= cifs_write(open_file
, open_file
->pid
,
1864 write_data
, to
- from
, &offset
);
1865 cifsFileInfo_put(open_file
);
1866 /* Does mm or vfs already set times? */
1867 inode
->i_atime
= inode
->i_mtime
= current_fs_time(inode
->i_sb
);
1868 if ((bytes_written
> 0) && (offset
))
1870 else if (bytes_written
< 0)
1873 cifs_dbg(FYI
, "No writeable filehandles for inode\n");
1881 static struct cifs_writedata
*
1882 wdata_alloc_and_fillpages(pgoff_t tofind
, struct address_space
*mapping
,
1883 pgoff_t end
, pgoff_t
*index
,
1884 unsigned int *found_pages
)
1886 unsigned int nr_pages
;
1887 struct page
**pages
;
1888 struct cifs_writedata
*wdata
;
1890 wdata
= cifs_writedata_alloc((unsigned int)tofind
,
1891 cifs_writev_complete
);
1896 * find_get_pages_tag seems to return a max of 256 on each
1897 * iteration, so we must call it several times in order to
1898 * fill the array or the wsize is effectively limited to
1899 * 256 * PAGE_CACHE_SIZE.
1902 pages
= wdata
->pages
;
1904 nr_pages
= find_get_pages_tag(mapping
, index
,
1905 PAGECACHE_TAG_DIRTY
, tofind
,
1907 *found_pages
+= nr_pages
;
1910 } while (nr_pages
&& tofind
&& *index
<= end
);
1916 wdata_prepare_pages(struct cifs_writedata
*wdata
, unsigned int found_pages
,
1917 struct address_space
*mapping
,
1918 struct writeback_control
*wbc
,
1919 pgoff_t end
, pgoff_t
*index
, pgoff_t
*next
, bool *done
)
1921 unsigned int nr_pages
= 0, i
;
1924 for (i
= 0; i
< found_pages
; i
++) {
1925 page
= wdata
->pages
[i
];
1927 * At this point we hold neither mapping->tree_lock nor
1928 * lock on the page itself: the page may be truncated or
1929 * invalidated (changing page->mapping to NULL), or even
1930 * swizzled back from swapper_space to tmpfs file
1936 else if (!trylock_page(page
))
1939 if (unlikely(page
->mapping
!= mapping
)) {
1944 if (!wbc
->range_cyclic
&& page
->index
> end
) {
1950 if (*next
&& (page
->index
!= *next
)) {
1951 /* Not next consecutive page */
1956 if (wbc
->sync_mode
!= WB_SYNC_NONE
)
1957 wait_on_page_writeback(page
);
1959 if (PageWriteback(page
) ||
1960 !clear_page_dirty_for_io(page
)) {
1966 * This actually clears the dirty bit in the radix tree.
1967 * See cifs_writepage() for more commentary.
1969 set_page_writeback(page
);
1970 if (page_offset(page
) >= i_size_read(mapping
->host
)) {
1973 end_page_writeback(page
);
1977 wdata
->pages
[i
] = page
;
1978 *next
= page
->index
+ 1;
1982 /* reset index to refind any pages skipped */
1984 *index
= wdata
->pages
[0]->index
+ 1;
1986 /* put any pages we aren't going to use */
1987 for (i
= nr_pages
; i
< found_pages
; i
++) {
1988 page_cache_release(wdata
->pages
[i
]);
1989 wdata
->pages
[i
] = NULL
;
1996 wdata_send_pages(struct cifs_writedata
*wdata
, unsigned int nr_pages
,
1997 struct address_space
*mapping
, struct writeback_control
*wbc
)
2000 struct TCP_Server_Info
*server
;
2003 wdata
->sync_mode
= wbc
->sync_mode
;
2004 wdata
->nr_pages
= nr_pages
;
2005 wdata
->offset
= page_offset(wdata
->pages
[0]);
2006 wdata
->pagesz
= PAGE_CACHE_SIZE
;
2007 wdata
->tailsz
= min(i_size_read(mapping
->host
) -
2008 page_offset(wdata
->pages
[nr_pages
- 1]),
2009 (loff_t
)PAGE_CACHE_SIZE
);
2010 wdata
->bytes
= ((nr_pages
- 1) * PAGE_CACHE_SIZE
) + wdata
->tailsz
;
2013 if (wdata
->cfile
!= NULL
)
2014 cifsFileInfo_put(wdata
->cfile
);
2015 wdata
->cfile
= find_writable_file(CIFS_I(mapping
->host
), false);
2016 if (!wdata
->cfile
) {
2017 cifs_dbg(VFS
, "No writable handles for inode\n");
2021 wdata
->pid
= wdata
->cfile
->pid
;
2022 server
= tlink_tcon(wdata
->cfile
->tlink
)->ses
->server
;
2023 rc
= server
->ops
->async_writev(wdata
, cifs_writedata_release
);
2024 } while (wbc
->sync_mode
== WB_SYNC_ALL
&& rc
== -EAGAIN
);
2026 for (i
= 0; i
< nr_pages
; ++i
)
2027 unlock_page(wdata
->pages
[i
]);
2032 static int cifs_writepages(struct address_space
*mapping
,
2033 struct writeback_control
*wbc
)
2035 struct cifs_sb_info
*cifs_sb
= CIFS_SB(mapping
->host
->i_sb
);
2036 bool done
= false, scanned
= false, range_whole
= false;
2038 struct cifs_writedata
*wdata
;
2042 * If wsize is smaller than the page cache size, default to writing
2043 * one page at a time via cifs_writepage
2045 if (cifs_sb
->wsize
< PAGE_CACHE_SIZE
)
2046 return generic_writepages(mapping
, wbc
);
2048 if (wbc
->range_cyclic
) {
2049 index
= mapping
->writeback_index
; /* Start from prev offset */
2052 index
= wbc
->range_start
>> PAGE_CACHE_SHIFT
;
2053 end
= wbc
->range_end
>> PAGE_CACHE_SHIFT
;
2054 if (wbc
->range_start
== 0 && wbc
->range_end
== LLONG_MAX
)
2059 while (!done
&& index
<= end
) {
2060 unsigned int i
, nr_pages
, found_pages
;
2061 pgoff_t next
= 0, tofind
;
2063 tofind
= min((cifs_sb
->wsize
/ PAGE_CACHE_SIZE
) - 1,
2066 wdata
= wdata_alloc_and_fillpages(tofind
, mapping
, end
, &index
,
2073 if (found_pages
== 0) {
2074 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2078 nr_pages
= wdata_prepare_pages(wdata
, found_pages
, mapping
, wbc
,
2079 end
, &index
, &next
, &done
);
2081 /* nothing to write? */
2082 if (nr_pages
== 0) {
2083 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2087 rc
= wdata_send_pages(wdata
, nr_pages
, mapping
, wbc
);
2089 /* send failure -- clean up the mess */
2091 for (i
= 0; i
< nr_pages
; ++i
) {
2093 redirty_page_for_writepage(wbc
,
2096 SetPageError(wdata
->pages
[i
]);
2097 end_page_writeback(wdata
->pages
[i
]);
2098 page_cache_release(wdata
->pages
[i
]);
2101 mapping_set_error(mapping
, rc
);
2103 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2105 wbc
->nr_to_write
-= nr_pages
;
2106 if (wbc
->nr_to_write
<= 0)
2112 if (!scanned
&& !done
) {
2114 * We hit the last page and there is more work to be done: wrap
2115 * back to the start of the file
2122 if (wbc
->range_cyclic
|| (range_whole
&& wbc
->nr_to_write
> 0))
2123 mapping
->writeback_index
= index
;
2129 cifs_writepage_locked(struct page
*page
, struct writeback_control
*wbc
)
2135 /* BB add check for wbc flags */
2136 page_cache_get(page
);
2137 if (!PageUptodate(page
))
2138 cifs_dbg(FYI
, "ppw - page not up to date\n");
2141 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2143 * A writepage() implementation always needs to do either this,
2144 * or re-dirty the page with "redirty_page_for_writepage()" in
2145 * the case of a failure.
2147 * Just unlocking the page will cause the radix tree tag-bits
2148 * to fail to update with the state of the page correctly.
2150 set_page_writeback(page
);
2152 rc
= cifs_partialpagewrite(page
, 0, PAGE_CACHE_SIZE
);
2153 if (rc
== -EAGAIN
&& wbc
->sync_mode
== WB_SYNC_ALL
)
2155 else if (rc
== -EAGAIN
)
2156 redirty_page_for_writepage(wbc
, page
);
2160 SetPageUptodate(page
);
2161 end_page_writeback(page
);
2162 page_cache_release(page
);
2167 static int cifs_writepage(struct page
*page
, struct writeback_control
*wbc
)
2169 int rc
= cifs_writepage_locked(page
, wbc
);
2174 static int cifs_write_end(struct file
*file
, struct address_space
*mapping
,
2175 loff_t pos
, unsigned len
, unsigned copied
,
2176 struct page
*page
, void *fsdata
)
2179 struct inode
*inode
= mapping
->host
;
2180 struct cifsFileInfo
*cfile
= file
->private_data
;
2181 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->dentry
->d_sb
);
2184 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
2187 pid
= current
->tgid
;
2189 cifs_dbg(FYI
, "write_end for page %p from pos %lld with %d bytes\n",
2192 if (PageChecked(page
)) {
2194 SetPageUptodate(page
);
2195 ClearPageChecked(page
);
2196 } else if (!PageUptodate(page
) && copied
== PAGE_CACHE_SIZE
)
2197 SetPageUptodate(page
);
2199 if (!PageUptodate(page
)) {
2201 unsigned offset
= pos
& (PAGE_CACHE_SIZE
- 1);
2205 /* this is probably better than directly calling
2206 partialpage_write since in this function the file handle is
2207 known which we might as well leverage */
2208 /* BB check if anything else missing out of ppw
2209 such as updating last write time */
2210 page_data
= kmap(page
);
2211 rc
= cifs_write(cfile
, pid
, page_data
+ offset
, copied
, &pos
);
2212 /* if (rc < 0) should we set writebehind rc? */
2219 set_page_dirty(page
);
2223 spin_lock(&inode
->i_lock
);
2224 if (pos
> inode
->i_size
)
2225 i_size_write(inode
, pos
);
2226 spin_unlock(&inode
->i_lock
);
2230 page_cache_release(page
);
2235 int cifs_strict_fsync(struct file
*file
, loff_t start
, loff_t end
,
2240 struct cifs_tcon
*tcon
;
2241 struct TCP_Server_Info
*server
;
2242 struct cifsFileInfo
*smbfile
= file
->private_data
;
2243 struct inode
*inode
= file_inode(file
);
2244 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2246 rc
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
2249 mutex_lock(&inode
->i_mutex
);
2253 cifs_dbg(FYI
, "Sync file - name: %s datasync: 0x%x\n",
2254 file
->f_path
.dentry
->d_name
.name
, datasync
);
2256 if (!CIFS_CACHE_READ(CIFS_I(inode
))) {
2257 rc
= cifs_zap_mapping(inode
);
2259 cifs_dbg(FYI
, "rc: %d during invalidate phase\n", rc
);
2260 rc
= 0; /* don't care about it in fsync */
2264 tcon
= tlink_tcon(smbfile
->tlink
);
2265 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
)) {
2266 server
= tcon
->ses
->server
;
2267 if (server
->ops
->flush
)
2268 rc
= server
->ops
->flush(xid
, tcon
, &smbfile
->fid
);
2274 mutex_unlock(&inode
->i_mutex
);
2278 int cifs_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
2282 struct cifs_tcon
*tcon
;
2283 struct TCP_Server_Info
*server
;
2284 struct cifsFileInfo
*smbfile
= file
->private_data
;
2285 struct cifs_sb_info
*cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
2286 struct inode
*inode
= file
->f_mapping
->host
;
2288 rc
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
2291 mutex_lock(&inode
->i_mutex
);
2295 cifs_dbg(FYI
, "Sync file - name: %s datasync: 0x%x\n",
2296 file
->f_path
.dentry
->d_name
.name
, datasync
);
2298 tcon
= tlink_tcon(smbfile
->tlink
);
2299 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
)) {
2300 server
= tcon
->ses
->server
;
2301 if (server
->ops
->flush
)
2302 rc
= server
->ops
->flush(xid
, tcon
, &smbfile
->fid
);
2308 mutex_unlock(&inode
->i_mutex
);
2313 * As file closes, flush all cached write data for this inode checking
2314 * for write behind errors.
2316 int cifs_flush(struct file
*file
, fl_owner_t id
)
2318 struct inode
*inode
= file_inode(file
);
2321 if (file
->f_mode
& FMODE_WRITE
)
2322 rc
= filemap_write_and_wait(inode
->i_mapping
);
2324 cifs_dbg(FYI
, "Flush inode %p file %p rc %d\n", inode
, file
, rc
);
2330 cifs_write_allocate_pages(struct page
**pages
, unsigned long num_pages
)
2335 for (i
= 0; i
< num_pages
; i
++) {
2336 pages
[i
] = alloc_page(GFP_KERNEL
|__GFP_HIGHMEM
);
2339 * save number of pages we have already allocated and
2340 * return with ENOMEM error
2349 for (i
= 0; i
< num_pages
; i
++)
2356 size_t get_numpages(const size_t wsize
, const size_t len
, size_t *cur_len
)
2361 clen
= min_t(const size_t, len
, wsize
);
2362 num_pages
= DIV_ROUND_UP(clen
, PAGE_SIZE
);
2371 cifs_uncached_writedata_release(struct kref
*refcount
)
2374 struct cifs_writedata
*wdata
= container_of(refcount
,
2375 struct cifs_writedata
, refcount
);
2377 for (i
= 0; i
< wdata
->nr_pages
; i
++)
2378 put_page(wdata
->pages
[i
]);
2379 cifs_writedata_release(refcount
);
2383 cifs_uncached_writev_complete(struct work_struct
*work
)
2385 struct cifs_writedata
*wdata
= container_of(work
,
2386 struct cifs_writedata
, work
);
2387 struct inode
*inode
= wdata
->cfile
->dentry
->d_inode
;
2388 struct cifsInodeInfo
*cifsi
= CIFS_I(inode
);
2390 spin_lock(&inode
->i_lock
);
2391 cifs_update_eof(cifsi
, wdata
->offset
, wdata
->bytes
);
2392 if (cifsi
->server_eof
> inode
->i_size
)
2393 i_size_write(inode
, cifsi
->server_eof
);
2394 spin_unlock(&inode
->i_lock
);
2396 complete(&wdata
->done
);
2398 kref_put(&wdata
->refcount
, cifs_uncached_writedata_release
);
2401 /* attempt to send write to server, retry on any -EAGAIN errors */
2403 cifs_uncached_retry_writev(struct cifs_writedata
*wdata
)
2406 struct TCP_Server_Info
*server
;
2408 server
= tlink_tcon(wdata
->cfile
->tlink
)->ses
->server
;
2411 if (wdata
->cfile
->invalidHandle
) {
2412 rc
= cifs_reopen_file(wdata
->cfile
, false);
2416 rc
= server
->ops
->async_writev(wdata
,
2417 cifs_uncached_writedata_release
);
2418 } while (rc
== -EAGAIN
);
2424 cifs_iovec_write(struct file
*file
, struct iov_iter
*from
, loff_t
*poffset
)
2426 unsigned long nr_pages
, i
;
2427 size_t bytes
, copied
, len
, cur_len
;
2428 ssize_t total_written
= 0;
2430 struct cifsFileInfo
*open_file
;
2431 struct cifs_tcon
*tcon
;
2432 struct cifs_sb_info
*cifs_sb
;
2433 struct cifs_writedata
*wdata
, *tmp
;
2434 struct list_head wdata_list
;
2438 len
= iov_iter_count(from
);
2439 rc
= generic_write_checks(file
, poffset
, &len
, 0);
2446 iov_iter_truncate(from
, len
);
2448 INIT_LIST_HEAD(&wdata_list
);
2449 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
2450 open_file
= file
->private_data
;
2451 tcon
= tlink_tcon(open_file
->tlink
);
2453 if (!tcon
->ses
->server
->ops
->async_writev
)
2458 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
2459 pid
= open_file
->pid
;
2461 pid
= current
->tgid
;
2466 nr_pages
= get_numpages(cifs_sb
->wsize
, len
, &cur_len
);
2467 wdata
= cifs_writedata_alloc(nr_pages
,
2468 cifs_uncached_writev_complete
);
2474 rc
= cifs_write_allocate_pages(wdata
->pages
, nr_pages
);
2481 for (i
= 0; i
< nr_pages
; i
++) {
2482 bytes
= min_t(size_t, cur_len
, PAGE_SIZE
);
2483 copied
= copy_page_from_iter(wdata
->pages
[i
], 0, bytes
,
2487 * If we didn't copy as much as we expected, then that
2488 * may mean we trod into an unmapped area. Stop copying
2489 * at that point. On the next pass through the big
2490 * loop, we'll likely end up getting a zero-length
2491 * write and bailing out of it.
2496 cur_len
= save_len
- cur_len
;
2499 * If we have no data to send, then that probably means that
2500 * the copy above failed altogether. That's most likely because
2501 * the address in the iovec was bogus. Set the rc to -EFAULT,
2502 * free anything we allocated and bail out.
2505 for (i
= 0; i
< nr_pages
; i
++)
2506 put_page(wdata
->pages
[i
]);
2513 * i + 1 now represents the number of pages we actually used in
2514 * the copy phase above. Bring nr_pages down to that, and free
2515 * any pages that we didn't use.
2517 for ( ; nr_pages
> i
+ 1; nr_pages
--)
2518 put_page(wdata
->pages
[nr_pages
- 1]);
2520 wdata
->sync_mode
= WB_SYNC_ALL
;
2521 wdata
->nr_pages
= nr_pages
;
2522 wdata
->offset
= (__u64
)offset
;
2523 wdata
->cfile
= cifsFileInfo_get(open_file
);
2525 wdata
->bytes
= cur_len
;
2526 wdata
->pagesz
= PAGE_SIZE
;
2527 wdata
->tailsz
= cur_len
- ((nr_pages
- 1) * PAGE_SIZE
);
2528 rc
= cifs_uncached_retry_writev(wdata
);
2530 kref_put(&wdata
->refcount
,
2531 cifs_uncached_writedata_release
);
2535 list_add_tail(&wdata
->list
, &wdata_list
);
2541 * If at least one write was successfully sent, then discard any rc
2542 * value from the later writes. If the other write succeeds, then
2543 * we'll end up returning whatever was written. If it fails, then
2544 * we'll get a new rc value from that.
2546 if (!list_empty(&wdata_list
))
2550 * Wait for and collect replies for any successful sends in order of
2551 * increasing offset. Once an error is hit or we get a fatal signal
2552 * while waiting, then return without waiting for any more replies.
2555 list_for_each_entry_safe(wdata
, tmp
, &wdata_list
, list
) {
2557 /* FIXME: freezable too? */
2558 rc
= wait_for_completion_killable(&wdata
->done
);
2561 else if (wdata
->result
)
2564 total_written
+= wdata
->bytes
;
2566 /* resend call if it's a retryable error */
2567 if (rc
== -EAGAIN
) {
2568 rc
= cifs_uncached_retry_writev(wdata
);
2572 list_del_init(&wdata
->list
);
2573 kref_put(&wdata
->refcount
, cifs_uncached_writedata_release
);
2576 if (total_written
> 0)
2577 *poffset
+= total_written
;
2579 cifs_stats_bytes_written(tcon
, total_written
);
2580 return total_written
? total_written
: (ssize_t
)rc
;
2583 ssize_t
cifs_user_writev(struct kiocb
*iocb
, struct iov_iter
*from
)
2586 struct inode
*inode
;
2587 loff_t pos
= iocb
->ki_pos
;
2589 inode
= file_inode(iocb
->ki_filp
);
2592 * BB - optimize the way when signing is disabled. We can drop this
2593 * extra memory-to-memory copying and use iovec buffers for constructing
2597 written
= cifs_iovec_write(iocb
->ki_filp
, from
, &pos
);
2599 set_bit(CIFS_INO_INVALID_MAPPING
, &CIFS_I(inode
)->flags
);
2607 cifs_writev(struct kiocb
*iocb
, struct iov_iter
*from
)
2609 struct file
*file
= iocb
->ki_filp
;
2610 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)file
->private_data
;
2611 struct inode
*inode
= file
->f_mapping
->host
;
2612 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
2613 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
2614 ssize_t rc
= -EACCES
;
2615 loff_t lock_pos
= iocb
->ki_pos
;
2618 * We need to hold the sem to be sure nobody modifies lock list
2619 * with a brlock that prevents writing.
2621 down_read(&cinode
->lock_sem
);
2622 mutex_lock(&inode
->i_mutex
);
2623 if (file
->f_flags
& O_APPEND
)
2624 lock_pos
= i_size_read(inode
);
2625 if (!cifs_find_lock_conflict(cfile
, lock_pos
, iov_iter_count(from
),
2626 server
->vals
->exclusive_lock_type
, NULL
,
2628 rc
= __generic_file_write_iter(iocb
, from
);
2629 mutex_unlock(&inode
->i_mutex
);
2634 err
= generic_write_sync(file
, iocb
->ki_pos
- rc
, rc
);
2639 mutex_unlock(&inode
->i_mutex
);
2641 up_read(&cinode
->lock_sem
);
2646 cifs_strict_writev(struct kiocb
*iocb
, struct iov_iter
*from
)
2648 struct inode
*inode
= file_inode(iocb
->ki_filp
);
2649 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
2650 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2651 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)
2652 iocb
->ki_filp
->private_data
;
2653 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
2656 written
= cifs_get_writer(cinode
);
2660 if (CIFS_CACHE_WRITE(cinode
)) {
2661 if (cap_unix(tcon
->ses
) &&
2662 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
))
2663 && ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0)) {
2664 written
= generic_file_write_iter(iocb
, from
);
2667 written
= cifs_writev(iocb
, from
);
2671 * For non-oplocked files in strict cache mode we need to write the data
2672 * to the server exactly from the pos to pos+len-1 rather than flush all
2673 * affected pages because it may cause a error with mandatory locks on
2674 * these pages but not on the region from pos to ppos+len-1.
2676 written
= cifs_user_writev(iocb
, from
);
2677 if (written
> 0 && CIFS_CACHE_READ(cinode
)) {
2679 * Windows 7 server can delay breaking level2 oplock if a write
2680 * request comes - break it on the client to prevent reading
2683 cifs_zap_mapping(inode
);
2684 cifs_dbg(FYI
, "Set no oplock for inode=%p after a write operation\n",
2689 cifs_put_writer(cinode
);
2693 static struct cifs_readdata
*
2694 cifs_readdata_alloc(unsigned int nr_pages
, work_func_t complete
)
2696 struct cifs_readdata
*rdata
;
2698 rdata
= kzalloc(sizeof(*rdata
) + (sizeof(struct page
*) * nr_pages
),
2700 if (rdata
!= NULL
) {
2701 kref_init(&rdata
->refcount
);
2702 INIT_LIST_HEAD(&rdata
->list
);
2703 init_completion(&rdata
->done
);
2704 INIT_WORK(&rdata
->work
, complete
);
2711 cifs_readdata_release(struct kref
*refcount
)
2713 struct cifs_readdata
*rdata
= container_of(refcount
,
2714 struct cifs_readdata
, refcount
);
2717 cifsFileInfo_put(rdata
->cfile
);
2723 cifs_read_allocate_pages(struct cifs_readdata
*rdata
, unsigned int nr_pages
)
2729 for (i
= 0; i
< nr_pages
; i
++) {
2730 page
= alloc_page(GFP_KERNEL
|__GFP_HIGHMEM
);
2735 rdata
->pages
[i
] = page
;
2739 for (i
= 0; i
< nr_pages
; i
++) {
2740 put_page(rdata
->pages
[i
]);
2741 rdata
->pages
[i
] = NULL
;
2748 cifs_uncached_readdata_release(struct kref
*refcount
)
2750 struct cifs_readdata
*rdata
= container_of(refcount
,
2751 struct cifs_readdata
, refcount
);
2754 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
2755 put_page(rdata
->pages
[i
]);
2756 rdata
->pages
[i
] = NULL
;
2758 cifs_readdata_release(refcount
);
2762 cifs_retry_async_readv(struct cifs_readdata
*rdata
)
2765 struct TCP_Server_Info
*server
;
2767 server
= tlink_tcon(rdata
->cfile
->tlink
)->ses
->server
;
2770 if (rdata
->cfile
->invalidHandle
) {
2771 rc
= cifs_reopen_file(rdata
->cfile
, true);
2775 rc
= server
->ops
->async_readv(rdata
);
2776 } while (rc
== -EAGAIN
);
2782 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2783 * @rdata: the readdata response with list of pages holding data
2784 * @iter: destination for our data
2786 * This function copies data from a list of pages in a readdata response into
2787 * an array of iovecs. It will first calculate where the data should go
2788 * based on the info in the readdata and then copy the data into that spot.
2791 cifs_readdata_to_iov(struct cifs_readdata
*rdata
, struct iov_iter
*iter
)
2793 size_t remaining
= rdata
->bytes
;
2796 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
2797 struct page
*page
= rdata
->pages
[i
];
2798 size_t copy
= min_t(size_t, remaining
, PAGE_SIZE
);
2799 size_t written
= copy_page_to_iter(page
, 0, copy
, iter
);
2800 remaining
-= written
;
2801 if (written
< copy
&& iov_iter_count(iter
) > 0)
2804 return remaining
? -EFAULT
: 0;
2808 cifs_uncached_readv_complete(struct work_struct
*work
)
2810 struct cifs_readdata
*rdata
= container_of(work
,
2811 struct cifs_readdata
, work
);
2813 complete(&rdata
->done
);
2814 kref_put(&rdata
->refcount
, cifs_uncached_readdata_release
);
2818 cifs_uncached_read_into_pages(struct TCP_Server_Info
*server
,
2819 struct cifs_readdata
*rdata
, unsigned int len
)
2821 int total_read
= 0, result
= 0;
2823 unsigned int nr_pages
= rdata
->nr_pages
;
2826 rdata
->tailsz
= PAGE_SIZE
;
2827 for (i
= 0; i
< nr_pages
; i
++) {
2828 struct page
*page
= rdata
->pages
[i
];
2830 if (len
>= PAGE_SIZE
) {
2831 /* enough data to fill the page */
2832 iov
.iov_base
= kmap(page
);
2833 iov
.iov_len
= PAGE_SIZE
;
2834 cifs_dbg(FYI
, "%u: iov_base=%p iov_len=%zu\n",
2835 i
, iov
.iov_base
, iov
.iov_len
);
2837 } else if (len
> 0) {
2838 /* enough for partial page, fill and zero the rest */
2839 iov
.iov_base
= kmap(page
);
2841 cifs_dbg(FYI
, "%u: iov_base=%p iov_len=%zu\n",
2842 i
, iov
.iov_base
, iov
.iov_len
);
2843 memset(iov
.iov_base
+ len
, '\0', PAGE_SIZE
- len
);
2844 rdata
->tailsz
= len
;
2847 /* no need to hold page hostage */
2848 rdata
->pages
[i
] = NULL
;
2854 result
= cifs_readv_from_socket(server
, &iov
, 1, iov
.iov_len
);
2859 total_read
+= result
;
2862 return total_read
> 0 && result
!= -EAGAIN
? total_read
: result
;
2865 ssize_t
cifs_user_readv(struct kiocb
*iocb
, struct iov_iter
*to
)
2867 struct file
*file
= iocb
->ki_filp
;
2869 size_t len
, cur_len
;
2870 ssize_t total_read
= 0;
2871 loff_t offset
= iocb
->ki_pos
;
2872 unsigned int npages
;
2873 struct cifs_sb_info
*cifs_sb
;
2874 struct cifs_tcon
*tcon
;
2875 struct cifsFileInfo
*open_file
;
2876 struct cifs_readdata
*rdata
, *tmp
;
2877 struct list_head rdata_list
;
2880 len
= iov_iter_count(to
);
2884 INIT_LIST_HEAD(&rdata_list
);
2885 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
2886 open_file
= file
->private_data
;
2887 tcon
= tlink_tcon(open_file
->tlink
);
2889 if (!tcon
->ses
->server
->ops
->async_readv
)
2892 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
2893 pid
= open_file
->pid
;
2895 pid
= current
->tgid
;
2897 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
2898 cifs_dbg(FYI
, "attempting read on write only file instance\n");
2901 cur_len
= min_t(const size_t, len
- total_read
, cifs_sb
->rsize
);
2902 npages
= DIV_ROUND_UP(cur_len
, PAGE_SIZE
);
2904 /* allocate a readdata struct */
2905 rdata
= cifs_readdata_alloc(npages
,
2906 cifs_uncached_readv_complete
);
2912 rc
= cifs_read_allocate_pages(rdata
, npages
);
2916 rdata
->cfile
= cifsFileInfo_get(open_file
);
2917 rdata
->nr_pages
= npages
;
2918 rdata
->offset
= offset
;
2919 rdata
->bytes
= cur_len
;
2921 rdata
->pagesz
= PAGE_SIZE
;
2922 rdata
->read_into_pages
= cifs_uncached_read_into_pages
;
2924 rc
= cifs_retry_async_readv(rdata
);
2927 kref_put(&rdata
->refcount
,
2928 cifs_uncached_readdata_release
);
2932 list_add_tail(&rdata
->list
, &rdata_list
);
2937 /* if at least one read request send succeeded, then reset rc */
2938 if (!list_empty(&rdata_list
))
2941 len
= iov_iter_count(to
);
2942 /* the loop below should proceed in the order of increasing offsets */
2943 list_for_each_entry_safe(rdata
, tmp
, &rdata_list
, list
) {
2946 /* FIXME: freezable sleep too? */
2947 rc
= wait_for_completion_killable(&rdata
->done
);
2950 else if (rdata
->result
) {
2952 /* resend call if it's a retryable error */
2953 if (rc
== -EAGAIN
) {
2954 rc
= cifs_retry_async_readv(rdata
);
2958 rc
= cifs_readdata_to_iov(rdata
, to
);
2962 list_del_init(&rdata
->list
);
2963 kref_put(&rdata
->refcount
, cifs_uncached_readdata_release
);
2966 total_read
= len
- iov_iter_count(to
);
2968 cifs_stats_bytes_read(tcon
, total_read
);
2970 /* mask nodata case */
2975 iocb
->ki_pos
+= total_read
;
2982 cifs_strict_readv(struct kiocb
*iocb
, struct iov_iter
*to
)
2984 struct inode
*inode
= file_inode(iocb
->ki_filp
);
2985 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
2986 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2987 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)
2988 iocb
->ki_filp
->private_data
;
2989 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
2993 * In strict cache mode we need to read from the server all the time
2994 * if we don't have level II oplock because the server can delay mtime
2995 * change - so we can't make a decision about inode invalidating.
2996 * And we can also fail with pagereading if there are mandatory locks
2997 * on pages affected by this read but not on the region from pos to
3000 if (!CIFS_CACHE_READ(cinode
))
3001 return cifs_user_readv(iocb
, to
);
3003 if (cap_unix(tcon
->ses
) &&
3004 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
3005 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
3006 return generic_file_read_iter(iocb
, to
);
3009 * We need to hold the sem to be sure nobody modifies lock list
3010 * with a brlock that prevents reading.
3012 down_read(&cinode
->lock_sem
);
3013 if (!cifs_find_lock_conflict(cfile
, iocb
->ki_pos
, iov_iter_count(to
),
3014 tcon
->ses
->server
->vals
->shared_lock_type
,
3015 NULL
, CIFS_READ_OP
))
3016 rc
= generic_file_read_iter(iocb
, to
);
3017 up_read(&cinode
->lock_sem
);
3022 cifs_read(struct file
*file
, char *read_data
, size_t read_size
, loff_t
*offset
)
3025 unsigned int bytes_read
= 0;
3026 unsigned int total_read
;
3027 unsigned int current_read_size
;
3029 struct cifs_sb_info
*cifs_sb
;
3030 struct cifs_tcon
*tcon
;
3031 struct TCP_Server_Info
*server
;
3034 struct cifsFileInfo
*open_file
;
3035 struct cifs_io_parms io_parms
;
3036 int buf_type
= CIFS_NO_BUFFER
;
3040 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
3042 /* FIXME: set up handlers for larger reads and/or convert to async */
3043 rsize
= min_t(unsigned int, cifs_sb
->rsize
, CIFSMaxBufSize
);
3045 if (file
->private_data
== NULL
) {
3050 open_file
= file
->private_data
;
3051 tcon
= tlink_tcon(open_file
->tlink
);
3052 server
= tcon
->ses
->server
;
3054 if (!server
->ops
->sync_read
) {
3059 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
3060 pid
= open_file
->pid
;
3062 pid
= current
->tgid
;
3064 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
3065 cifs_dbg(FYI
, "attempting read on write only file instance\n");
3067 for (total_read
= 0, cur_offset
= read_data
; read_size
> total_read
;
3068 total_read
+= bytes_read
, cur_offset
+= bytes_read
) {
3069 current_read_size
= min_t(uint
, read_size
- total_read
, rsize
);
3071 * For windows me and 9x we do not want to request more than it
3072 * negotiated since it will refuse the read then.
3074 if ((tcon
->ses
) && !(tcon
->ses
->capabilities
&
3075 tcon
->ses
->server
->vals
->cap_large_files
)) {
3076 current_read_size
= min_t(uint
, current_read_size
,
3080 while (rc
== -EAGAIN
) {
3081 if (open_file
->invalidHandle
) {
3082 rc
= cifs_reopen_file(open_file
, true);
3087 io_parms
.tcon
= tcon
;
3088 io_parms
.offset
= *offset
;
3089 io_parms
.length
= current_read_size
;
3090 rc
= server
->ops
->sync_read(xid
, open_file
, &io_parms
,
3091 &bytes_read
, &cur_offset
,
3094 if (rc
|| (bytes_read
== 0)) {
3102 cifs_stats_bytes_read(tcon
, total_read
);
3103 *offset
+= bytes_read
;
3111 * If the page is mmap'ed into a process' page tables, then we need to make
3112 * sure that it doesn't change while being written back.
3115 cifs_page_mkwrite(struct vm_area_struct
*vma
, struct vm_fault
*vmf
)
3117 struct page
*page
= vmf
->page
;
3120 return VM_FAULT_LOCKED
;
3123 static struct vm_operations_struct cifs_file_vm_ops
= {
3124 .fault
= filemap_fault
,
3125 .map_pages
= filemap_map_pages
,
3126 .page_mkwrite
= cifs_page_mkwrite
,
3127 .remap_pages
= generic_file_remap_pages
,
3130 int cifs_file_strict_mmap(struct file
*file
, struct vm_area_struct
*vma
)
3133 struct inode
*inode
= file_inode(file
);
3137 if (!CIFS_CACHE_READ(CIFS_I(inode
))) {
3138 rc
= cifs_zap_mapping(inode
);
3143 rc
= generic_file_mmap(file
, vma
);
3145 vma
->vm_ops
= &cifs_file_vm_ops
;
3150 int cifs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
3155 rc
= cifs_revalidate_file(file
);
3157 cifs_dbg(FYI
, "Validation prior to mmap failed, error=%d\n",
3162 rc
= generic_file_mmap(file
, vma
);
3164 vma
->vm_ops
= &cifs_file_vm_ops
;
3170 cifs_readv_complete(struct work_struct
*work
)
3173 struct cifs_readdata
*rdata
= container_of(work
,
3174 struct cifs_readdata
, work
);
3176 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
3177 struct page
*page
= rdata
->pages
[i
];
3179 lru_cache_add_file(page
);
3181 if (rdata
->result
== 0) {
3182 flush_dcache_page(page
);
3183 SetPageUptodate(page
);
3188 if (rdata
->result
== 0)
3189 cifs_readpage_to_fscache(rdata
->mapping
->host
, page
);
3191 page_cache_release(page
);
3192 rdata
->pages
[i
] = NULL
;
3194 kref_put(&rdata
->refcount
, cifs_readdata_release
);
3198 cifs_readpages_read_into_pages(struct TCP_Server_Info
*server
,
3199 struct cifs_readdata
*rdata
, unsigned int len
)
3201 int total_read
= 0, result
= 0;
3205 unsigned int nr_pages
= rdata
->nr_pages
;
3208 /* determine the eof that the server (probably) has */
3209 eof
= CIFS_I(rdata
->mapping
->host
)->server_eof
;
3210 eof_index
= eof
? (eof
- 1) >> PAGE_CACHE_SHIFT
: 0;
3211 cifs_dbg(FYI
, "eof=%llu eof_index=%lu\n", eof
, eof_index
);
3213 rdata
->tailsz
= PAGE_CACHE_SIZE
;
3214 for (i
= 0; i
< nr_pages
; i
++) {
3215 struct page
*page
= rdata
->pages
[i
];
3217 if (len
>= PAGE_CACHE_SIZE
) {
3218 /* enough data to fill the page */
3219 iov
.iov_base
= kmap(page
);
3220 iov
.iov_len
= PAGE_CACHE_SIZE
;
3221 cifs_dbg(FYI
, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3222 i
, page
->index
, iov
.iov_base
, iov
.iov_len
);
3223 len
-= PAGE_CACHE_SIZE
;
3224 } else if (len
> 0) {
3225 /* enough for partial page, fill and zero the rest */
3226 iov
.iov_base
= kmap(page
);
3228 cifs_dbg(FYI
, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3229 i
, page
->index
, iov
.iov_base
, iov
.iov_len
);
3230 memset(iov
.iov_base
+ len
,
3231 '\0', PAGE_CACHE_SIZE
- len
);
3232 rdata
->tailsz
= len
;
3234 } else if (page
->index
> eof_index
) {
3236 * The VFS will not try to do readahead past the
3237 * i_size, but it's possible that we have outstanding
3238 * writes with gaps in the middle and the i_size hasn't
3239 * caught up yet. Populate those with zeroed out pages
3240 * to prevent the VFS from repeatedly attempting to
3241 * fill them until the writes are flushed.
3243 zero_user(page
, 0, PAGE_CACHE_SIZE
);
3244 lru_cache_add_file(page
);
3245 flush_dcache_page(page
);
3246 SetPageUptodate(page
);
3248 page_cache_release(page
);
3249 rdata
->pages
[i
] = NULL
;
3253 /* no need to hold page hostage */
3254 lru_cache_add_file(page
);
3256 page_cache_release(page
);
3257 rdata
->pages
[i
] = NULL
;
3262 result
= cifs_readv_from_socket(server
, &iov
, 1, iov
.iov_len
);
3267 total_read
+= result
;
3270 return total_read
> 0 && result
!= -EAGAIN
? total_read
: result
;
3273 static int cifs_readpages(struct file
*file
, struct address_space
*mapping
,
3274 struct list_head
*page_list
, unsigned num_pages
)
3277 struct list_head tmplist
;
3278 struct cifsFileInfo
*open_file
= file
->private_data
;
3279 struct cifs_sb_info
*cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
3280 unsigned int rsize
= cifs_sb
->rsize
;
3284 * Give up immediately if rsize is too small to read an entire page.
3285 * The VFS will fall back to readpage. We should never reach this
3286 * point however since we set ra_pages to 0 when the rsize is smaller
3287 * than a cache page.
3289 if (unlikely(rsize
< PAGE_CACHE_SIZE
))
3293 * Reads as many pages as possible from fscache. Returns -ENOBUFS
3294 * immediately if the cookie is negative
3296 * After this point, every page in the list might have PG_fscache set,
3297 * so we will need to clean that up off of every page we don't use.
3299 rc
= cifs_readpages_from_fscache(mapping
->host
, mapping
, page_list
,
3304 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
3305 pid
= open_file
->pid
;
3307 pid
= current
->tgid
;
3310 INIT_LIST_HEAD(&tmplist
);
3312 cifs_dbg(FYI
, "%s: file=%p mapping=%p num_pages=%u\n",
3313 __func__
, file
, mapping
, num_pages
);
3316 * Start with the page at end of list and move it to private
3317 * list. Do the same with any following pages until we hit
3318 * the rsize limit, hit an index discontinuity, or run out of
3319 * pages. Issue the async read and then start the loop again
3320 * until the list is empty.
3322 * Note that list order is important. The page_list is in
3323 * the order of declining indexes. When we put the pages in
3324 * the rdata->pages, then we want them in increasing order.
3326 while (!list_empty(page_list
)) {
3328 unsigned int bytes
= PAGE_CACHE_SIZE
;
3329 unsigned int expected_index
;
3330 unsigned int nr_pages
= 1;
3332 struct page
*page
, *tpage
;
3333 struct cifs_readdata
*rdata
;
3335 page
= list_entry(page_list
->prev
, struct page
, lru
);
3338 * Lock the page and put it in the cache. Since no one else
3339 * should have access to this page, we're safe to simply set
3340 * PG_locked without checking it first.
3342 __set_page_locked(page
);
3343 rc
= add_to_page_cache_locked(page
, mapping
,
3344 page
->index
, GFP_KERNEL
);
3346 /* give up if we can't stick it in the cache */
3348 __clear_page_locked(page
);
3352 /* move first page to the tmplist */
3353 offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
3354 list_move_tail(&page
->lru
, &tmplist
);
3356 /* now try and add more pages onto the request */
3357 expected_index
= page
->index
+ 1;
3358 list_for_each_entry_safe_reverse(page
, tpage
, page_list
, lru
) {
3359 /* discontinuity ? */
3360 if (page
->index
!= expected_index
)
3363 /* would this page push the read over the rsize? */
3364 if (bytes
+ PAGE_CACHE_SIZE
> rsize
)
3367 __set_page_locked(page
);
3368 if (add_to_page_cache_locked(page
, mapping
,
3369 page
->index
, GFP_KERNEL
)) {
3370 __clear_page_locked(page
);
3373 list_move_tail(&page
->lru
, &tmplist
);
3374 bytes
+= PAGE_CACHE_SIZE
;
3379 rdata
= cifs_readdata_alloc(nr_pages
, cifs_readv_complete
);
3381 /* best to give up if we're out of mem */
3382 list_for_each_entry_safe(page
, tpage
, &tmplist
, lru
) {
3383 list_del(&page
->lru
);
3384 lru_cache_add_file(page
);
3386 page_cache_release(page
);
3392 rdata
->cfile
= cifsFileInfo_get(open_file
);
3393 rdata
->mapping
= mapping
;
3394 rdata
->offset
= offset
;
3395 rdata
->bytes
= bytes
;
3397 rdata
->pagesz
= PAGE_CACHE_SIZE
;
3398 rdata
->read_into_pages
= cifs_readpages_read_into_pages
;
3400 list_for_each_entry_safe(page
, tpage
, &tmplist
, lru
) {
3401 list_del(&page
->lru
);
3402 rdata
->pages
[rdata
->nr_pages
++] = page
;
3405 rc
= cifs_retry_async_readv(rdata
);
3407 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
3408 page
= rdata
->pages
[i
];
3409 lru_cache_add_file(page
);
3411 page_cache_release(page
);
3413 kref_put(&rdata
->refcount
, cifs_readdata_release
);
3417 kref_put(&rdata
->refcount
, cifs_readdata_release
);
3420 /* Any pages that have been shown to fscache but didn't get added to
3421 * the pagecache must be uncached before they get returned to the
3424 cifs_fscache_readpages_cancel(mapping
->host
, page_list
);
3429 * cifs_readpage_worker must be called with the page pinned
3431 static int cifs_readpage_worker(struct file
*file
, struct page
*page
,
3437 /* Is the page cached? */
3438 rc
= cifs_readpage_from_fscache(file_inode(file
), page
);
3442 read_data
= kmap(page
);
3443 /* for reads over a certain size could initiate async read ahead */
3445 rc
= cifs_read(file
, read_data
, PAGE_CACHE_SIZE
, poffset
);
3450 cifs_dbg(FYI
, "Bytes read %d\n", rc
);
3452 file_inode(file
)->i_atime
=
3453 current_fs_time(file_inode(file
)->i_sb
);
3455 if (PAGE_CACHE_SIZE
> rc
)
3456 memset(read_data
+ rc
, 0, PAGE_CACHE_SIZE
- rc
);
3458 flush_dcache_page(page
);
3459 SetPageUptodate(page
);
3461 /* send this page to the cache */
3462 cifs_readpage_to_fscache(file_inode(file
), page
);
3474 static int cifs_readpage(struct file
*file
, struct page
*page
)
3476 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
3482 if (file
->private_data
== NULL
) {
3488 cifs_dbg(FYI
, "readpage %p at offset %d 0x%x\n",
3489 page
, (int)offset
, (int)offset
);
3491 rc
= cifs_readpage_worker(file
, page
, &offset
);
3497 static int is_inode_writable(struct cifsInodeInfo
*cifs_inode
)
3499 struct cifsFileInfo
*open_file
;
3501 spin_lock(&cifs_file_list_lock
);
3502 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
3503 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_WRITE
) {
3504 spin_unlock(&cifs_file_list_lock
);
3508 spin_unlock(&cifs_file_list_lock
);
3512 /* We do not want to update the file size from server for inodes
3513 open for write - to avoid races with writepage extending
3514 the file - in the future we could consider allowing
3515 refreshing the inode only on increases in the file size
3516 but this is tricky to do without racing with writebehind
3517 page caching in the current Linux kernel design */
3518 bool is_size_safe_to_change(struct cifsInodeInfo
*cifsInode
, __u64 end_of_file
)
3523 if (is_inode_writable(cifsInode
)) {
3524 /* This inode is open for write at least once */
3525 struct cifs_sb_info
*cifs_sb
;
3527 cifs_sb
= CIFS_SB(cifsInode
->vfs_inode
.i_sb
);
3528 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
3529 /* since no page cache to corrupt on directio
3530 we can change size safely */
3534 if (i_size_read(&cifsInode
->vfs_inode
) < end_of_file
)
3542 static int cifs_write_begin(struct file
*file
, struct address_space
*mapping
,
3543 loff_t pos
, unsigned len
, unsigned flags
,
3544 struct page
**pagep
, void **fsdata
)
3547 pgoff_t index
= pos
>> PAGE_CACHE_SHIFT
;
3548 loff_t offset
= pos
& (PAGE_CACHE_SIZE
- 1);
3549 loff_t page_start
= pos
& PAGE_MASK
;
3554 cifs_dbg(FYI
, "write_begin from %lld len %d\n", (long long)pos
, len
);
3557 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
3563 if (PageUptodate(page
))
3567 * If we write a full page it will be up to date, no need to read from
3568 * the server. If the write is short, we'll end up doing a sync write
3571 if (len
== PAGE_CACHE_SIZE
)
3575 * optimize away the read when we have an oplock, and we're not
3576 * expecting to use any of the data we'd be reading in. That
3577 * is, when the page lies beyond the EOF, or straddles the EOF
3578 * and the write will cover all of the existing data.
3580 if (CIFS_CACHE_READ(CIFS_I(mapping
->host
))) {
3581 i_size
= i_size_read(mapping
->host
);
3582 if (page_start
>= i_size
||
3583 (offset
== 0 && (pos
+ len
) >= i_size
)) {
3584 zero_user_segments(page
, 0, offset
,
3588 * PageChecked means that the parts of the page
3589 * to which we're not writing are considered up
3590 * to date. Once the data is copied to the
3591 * page, it can be set uptodate.
3593 SetPageChecked(page
);
3598 if ((file
->f_flags
& O_ACCMODE
) != O_WRONLY
&& !oncethru
) {
3600 * might as well read a page, it is fast enough. If we get
3601 * an error, we don't need to return it. cifs_write_end will
3602 * do a sync write instead since PG_uptodate isn't set.
3604 cifs_readpage_worker(file
, page
, &page_start
);
3605 page_cache_release(page
);
3609 /* we could try using another file handle if there is one -
3610 but how would we lock it to prevent close of that handle
3611 racing with this read? In any case
3612 this will be written out by write_end so is fine */
3619 static int cifs_release_page(struct page
*page
, gfp_t gfp
)
3621 if (PagePrivate(page
))
3624 return cifs_fscache_release_page(page
, gfp
);
3627 static void cifs_invalidate_page(struct page
*page
, unsigned int offset
,
3628 unsigned int length
)
3630 struct cifsInodeInfo
*cifsi
= CIFS_I(page
->mapping
->host
);
3632 if (offset
== 0 && length
== PAGE_CACHE_SIZE
)
3633 cifs_fscache_invalidate_page(page
, &cifsi
->vfs_inode
);
3636 static int cifs_launder_page(struct page
*page
)
3639 loff_t range_start
= page_offset(page
);
3640 loff_t range_end
= range_start
+ (loff_t
)(PAGE_CACHE_SIZE
- 1);
3641 struct writeback_control wbc
= {
3642 .sync_mode
= WB_SYNC_ALL
,
3644 .range_start
= range_start
,
3645 .range_end
= range_end
,
3648 cifs_dbg(FYI
, "Launder page: %p\n", page
);
3650 if (clear_page_dirty_for_io(page
))
3651 rc
= cifs_writepage_locked(page
, &wbc
);
3653 cifs_fscache_invalidate_page(page
, page
->mapping
->host
);
3658 cifs_pending_writers_wait(void *unused
)
3664 void cifs_oplock_break(struct work_struct
*work
)
3666 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
3668 struct inode
*inode
= cfile
->dentry
->d_inode
;
3669 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
3670 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
3671 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
3674 wait_on_bit(&cinode
->flags
, CIFS_INODE_PENDING_WRITERS
,
3675 cifs_pending_writers_wait
, TASK_UNINTERRUPTIBLE
);
3677 server
->ops
->downgrade_oplock(server
, cinode
,
3678 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2
, &cinode
->flags
));
3680 if (!CIFS_CACHE_WRITE(cinode
) && CIFS_CACHE_READ(cinode
) &&
3681 cifs_has_mand_locks(cinode
)) {
3682 cifs_dbg(FYI
, "Reset oplock to None for inode=%p due to mand locks\n",
3687 if (inode
&& S_ISREG(inode
->i_mode
)) {
3688 if (CIFS_CACHE_READ(cinode
))
3689 break_lease(inode
, O_RDONLY
);
3691 break_lease(inode
, O_WRONLY
);
3692 rc
= filemap_fdatawrite(inode
->i_mapping
);
3693 if (!CIFS_CACHE_READ(cinode
)) {
3694 rc
= filemap_fdatawait(inode
->i_mapping
);
3695 mapping_set_error(inode
->i_mapping
, rc
);
3696 cifs_zap_mapping(inode
);
3698 cifs_dbg(FYI
, "Oplock flush inode %p rc %d\n", inode
, rc
);
3701 rc
= cifs_push_locks(cfile
);
3703 cifs_dbg(VFS
, "Push locks rc = %d\n", rc
);
3706 * releasing stale oplock after recent reconnect of smb session using
3707 * a now incorrect file handle is not a data integrity issue but do
3708 * not bother sending an oplock release if session to server still is
3709 * disconnected since oplock already released by the server
3711 if (!cfile
->oplock_break_cancelled
) {
3712 rc
= tcon
->ses
->server
->ops
->oplock_response(tcon
, &cfile
->fid
,
3714 cifs_dbg(FYI
, "Oplock release rc = %d\n", rc
);
3716 cifs_done_oplock_break(cinode
);
3720 * The presence of cifs_direct_io() in the address space ops vector
3721 * allowes open() O_DIRECT flags which would have failed otherwise.
3723 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
3724 * so this method should never be called.
3726 * Direct IO is not yet supported in the cached mode.
3729 cifs_direct_io(int rw
, struct kiocb
*iocb
, struct iov_iter
*iter
,
3734 * Eventually need to support direct IO for non forcedirectio mounts
3740 const struct address_space_operations cifs_addr_ops
= {
3741 .readpage
= cifs_readpage
,
3742 .readpages
= cifs_readpages
,
3743 .writepage
= cifs_writepage
,
3744 .writepages
= cifs_writepages
,
3745 .write_begin
= cifs_write_begin
,
3746 .write_end
= cifs_write_end
,
3747 .set_page_dirty
= __set_page_dirty_nobuffers
,
3748 .releasepage
= cifs_release_page
,
3749 .direct_IO
= cifs_direct_io
,
3750 .invalidatepage
= cifs_invalidate_page
,
3751 .launder_page
= cifs_launder_page
,
3755 * cifs_readpages requires the server to support a buffer large enough to
3756 * contain the header plus one complete page of data. Otherwise, we need
3757 * to leave cifs_readpages out of the address space operations.
3759 const struct address_space_operations cifs_addr_ops_smallbuf
= {
3760 .readpage
= cifs_readpage
,
3761 .writepage
= cifs_writepage
,
3762 .writepages
= cifs_writepages
,
3763 .write_begin
= cifs_write_begin
,
3764 .write_end
= cifs_write_end
,
3765 .set_page_dirty
= __set_page_dirty_nobuffers
,
3766 .releasepage
= cifs_release_page
,
3767 .invalidatepage
= cifs_invalidate_page
,
3768 .launder_page
= cifs_launder_page
,