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 cFYI(1, "Application %s pid %d has incorrectly set O_EXCL flag"
82 "but not O_CREAT on file open. Ignoring O_EXCL",
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 cFYI(1, "posix open %s", 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_sb
->mnt_cifs_flags
&
145 CIFS_MOUNT_MAP_SPECIAL_CHR
);
146 cifs_put_tlink(tlink
);
151 if (presp_data
->Type
== cpu_to_le32(-1))
152 goto posix_open_ret
; /* open ok, caller does qpathinfo */
155 goto posix_open_ret
; /* caller does not need info */
157 cifs_unix_basic_to_fattr(&fattr
, presp_data
, cifs_sb
);
159 /* get new inode and set it up */
160 if (*pinode
== NULL
) {
161 cifs_fill_uniqueid(sb
, &fattr
);
162 *pinode
= cifs_iget(sb
, &fattr
);
168 cifs_fattr_to_inode(*pinode
, &fattr
);
177 cifs_nt_open(char *full_path
, struct inode
*inode
, struct cifs_sb_info
*cifs_sb
,
178 struct cifs_tcon
*tcon
, unsigned int f_flags
, __u32
*oplock
,
179 struct cifs_fid
*fid
, unsigned int xid
)
184 int create_options
= CREATE_NOT_DIR
;
186 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
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 rc
= server
->ops
->open(xid
, tcon
, full_path
, disposition
,
229 desired_access
, create_options
, fid
, oplock
, buf
,
236 rc
= cifs_get_inode_info_unix(&inode
, full_path
, inode
->i_sb
,
239 rc
= cifs_get_inode_info(&inode
, full_path
, buf
, inode
->i_sb
,
248 cifs_has_mand_locks(struct cifsInodeInfo
*cinode
)
250 struct cifs_fid_locks
*cur
;
251 bool has_locks
= false;
253 down_read(&cinode
->lock_sem
);
254 list_for_each_entry(cur
, &cinode
->llist
, llist
) {
255 if (!list_empty(&cur
->locks
)) {
260 up_read(&cinode
->lock_sem
);
264 struct cifsFileInfo
*
265 cifs_new_fileinfo(struct cifs_fid
*fid
, struct file
*file
,
266 struct tcon_link
*tlink
, __u32 oplock
)
268 struct dentry
*dentry
= file
->f_path
.dentry
;
269 struct inode
*inode
= dentry
->d_inode
;
270 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
271 struct cifsFileInfo
*cfile
;
272 struct cifs_fid_locks
*fdlocks
;
273 struct cifs_tcon
*tcon
= tlink_tcon(tlink
);
274 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
276 cfile
= kzalloc(sizeof(struct cifsFileInfo
), GFP_KERNEL
);
280 fdlocks
= kzalloc(sizeof(struct cifs_fid_locks
), GFP_KERNEL
);
286 INIT_LIST_HEAD(&fdlocks
->locks
);
287 fdlocks
->cfile
= cfile
;
288 cfile
->llist
= fdlocks
;
289 down_write(&cinode
->lock_sem
);
290 list_add(&fdlocks
->llist
, &cinode
->llist
);
291 up_write(&cinode
->lock_sem
);
294 cfile
->pid
= current
->tgid
;
295 cfile
->uid
= current_fsuid();
296 cfile
->dentry
= dget(dentry
);
297 cfile
->f_flags
= file
->f_flags
;
298 cfile
->invalidHandle
= false;
299 cfile
->tlink
= cifs_get_tlink(tlink
);
300 INIT_WORK(&cfile
->oplock_break
, cifs_oplock_break
);
301 mutex_init(&cfile
->fh_mutex
);
304 * If the server returned a read oplock and we have mandatory brlocks,
305 * set oplock level to None.
307 if (oplock
== server
->vals
->oplock_read
&&
308 cifs_has_mand_locks(cinode
)) {
309 cFYI(1, "Reset oplock val from read to None due to mand locks");
313 spin_lock(&cifs_file_list_lock
);
314 if (fid
->pending_open
->oplock
!= CIFS_OPLOCK_NO_CHANGE
&& oplock
)
315 oplock
= fid
->pending_open
->oplock
;
316 list_del(&fid
->pending_open
->olist
);
318 server
->ops
->set_fid(cfile
, fid
, oplock
);
320 list_add(&cfile
->tlist
, &tcon
->openFileList
);
321 /* if readable file instance put first in list*/
322 if (file
->f_mode
& FMODE_READ
)
323 list_add(&cfile
->flist
, &cinode
->openFileList
);
325 list_add_tail(&cfile
->flist
, &cinode
->openFileList
);
326 spin_unlock(&cifs_file_list_lock
);
328 file
->private_data
= cfile
;
332 struct cifsFileInfo
*
333 cifsFileInfo_get(struct cifsFileInfo
*cifs_file
)
335 spin_lock(&cifs_file_list_lock
);
336 cifsFileInfo_get_locked(cifs_file
);
337 spin_unlock(&cifs_file_list_lock
);
342 * Release a reference on the file private data. This may involve closing
343 * the filehandle out on the server. Must be called without holding
344 * cifs_file_list_lock.
346 void cifsFileInfo_put(struct cifsFileInfo
*cifs_file
)
348 struct inode
*inode
= cifs_file
->dentry
->d_inode
;
349 struct cifs_tcon
*tcon
= tlink_tcon(cifs_file
->tlink
);
350 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
351 struct cifsInodeInfo
*cifsi
= CIFS_I(inode
);
352 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
353 struct cifsLockInfo
*li
, *tmp
;
355 struct cifs_pending_open open
;
357 spin_lock(&cifs_file_list_lock
);
358 if (--cifs_file
->count
> 0) {
359 spin_unlock(&cifs_file_list_lock
);
363 if (server
->ops
->get_lease_key
)
364 server
->ops
->get_lease_key(inode
, &fid
);
366 /* store open in pending opens to make sure we don't miss lease break */
367 cifs_add_pending_open_locked(&fid
, cifs_file
->tlink
, &open
);
369 /* remove it from the lists */
370 list_del(&cifs_file
->flist
);
371 list_del(&cifs_file
->tlist
);
373 if (list_empty(&cifsi
->openFileList
)) {
374 cFYI(1, "closing last open instance for inode %p",
375 cifs_file
->dentry
->d_inode
);
377 * In strict cache mode we need invalidate mapping on the last
378 * close because it may cause a error when we open this file
379 * again and get at least level II oplock.
381 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_STRICT_IO
)
382 CIFS_I(inode
)->invalid_mapping
= true;
383 cifs_set_oplock_level(cifsi
, 0);
385 spin_unlock(&cifs_file_list_lock
);
387 cancel_work_sync(&cifs_file
->oplock_break
);
389 if (!tcon
->need_reconnect
&& !cifs_file
->invalidHandle
) {
390 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
394 if (server
->ops
->close
)
395 server
->ops
->close(xid
, tcon
, &cifs_file
->fid
);
399 cifs_del_pending_open(&open
);
402 * Delete any outstanding lock records. We'll lose them when the file
405 down_write(&cifsi
->lock_sem
);
406 list_for_each_entry_safe(li
, tmp
, &cifs_file
->llist
->locks
, llist
) {
407 list_del(&li
->llist
);
408 cifs_del_lock_waiters(li
);
411 list_del(&cifs_file
->llist
->llist
);
412 kfree(cifs_file
->llist
);
413 up_write(&cifsi
->lock_sem
);
415 cifs_put_tlink(cifs_file
->tlink
);
416 dput(cifs_file
->dentry
);
420 int cifs_open(struct inode
*inode
, struct file
*file
)
426 struct cifs_sb_info
*cifs_sb
;
427 struct TCP_Server_Info
*server
;
428 struct cifs_tcon
*tcon
;
429 struct tcon_link
*tlink
;
430 struct cifsFileInfo
*cfile
= NULL
;
431 char *full_path
= NULL
;
432 bool posix_open_ok
= false;
434 struct cifs_pending_open open
;
438 cifs_sb
= CIFS_SB(inode
->i_sb
);
439 tlink
= cifs_sb_tlink(cifs_sb
);
442 return PTR_ERR(tlink
);
444 tcon
= tlink_tcon(tlink
);
445 server
= tcon
->ses
->server
;
447 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
448 if (full_path
== NULL
) {
453 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
454 inode
, file
->f_flags
, full_path
);
461 if (!tcon
->broken_posix_open
&& tcon
->unix_ext
&&
462 cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
463 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
464 /* can not refresh inode info since size could be stale */
465 rc
= cifs_posix_open(full_path
, &inode
, inode
->i_sb
,
466 cifs_sb
->mnt_file_mode
/* ignored */,
467 file
->f_flags
, &oplock
, &fid
.netfid
, xid
);
469 cFYI(1, "posix open succeeded");
470 posix_open_ok
= true;
471 } else if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
472 if (tcon
->ses
->serverNOS
)
473 cERROR(1, "server %s of type %s returned"
474 " unexpected error on SMB posix open"
475 ", disabling posix open support."
476 " Check if server update available.",
477 tcon
->ses
->serverName
,
478 tcon
->ses
->serverNOS
);
479 tcon
->broken_posix_open
= true;
480 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
481 (rc
!= -EOPNOTSUPP
)) /* path not found or net err */
484 * Else fallthrough to retry open the old way on network i/o
489 if (server
->ops
->get_lease_key
)
490 server
->ops
->get_lease_key(inode
, &fid
);
492 cifs_add_pending_open(&fid
, tlink
, &open
);
494 if (!posix_open_ok
) {
495 if (server
->ops
->get_lease_key
)
496 server
->ops
->get_lease_key(inode
, &fid
);
498 rc
= cifs_nt_open(full_path
, inode
, cifs_sb
, tcon
,
499 file
->f_flags
, &oplock
, &fid
, xid
);
501 cifs_del_pending_open(&open
);
506 cfile
= cifs_new_fileinfo(&fid
, file
, tlink
, oplock
);
508 if (server
->ops
->close
)
509 server
->ops
->close(xid
, tcon
, &fid
);
510 cifs_del_pending_open(&open
);
515 cifs_fscache_set_inode_cookie(inode
, file
);
517 if ((oplock
& CIFS_CREATE_ACTION
) && !posix_open_ok
&& tcon
->unix_ext
) {
519 * Time to set mode which we can not set earlier due to
520 * problems creating new read-only files.
522 struct cifs_unix_set_info_args args
= {
523 .mode
= inode
->i_mode
,
524 .uid
= INVALID_UID
, /* no change */
525 .gid
= INVALID_GID
, /* no change */
526 .ctime
= NO_CHANGE_64
,
527 .atime
= NO_CHANGE_64
,
528 .mtime
= NO_CHANGE_64
,
531 CIFSSMBUnixSetFileInfo(xid
, tcon
, &args
, fid
.netfid
,
538 cifs_put_tlink(tlink
);
542 static int cifs_push_posix_locks(struct cifsFileInfo
*cfile
);
545 * Try to reacquire byte range locks that were released when session
546 * to server was lost.
549 cifs_relock_file(struct cifsFileInfo
*cfile
)
551 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->dentry
->d_sb
);
552 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
553 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
556 /* we are going to update can_cache_brlcks here - need a write access */
557 down_write(&cinode
->lock_sem
);
558 if (cinode
->can_cache_brlcks
) {
559 /* can cache locks - no need to push them */
560 up_write(&cinode
->lock_sem
);
564 if (cap_unix(tcon
->ses
) &&
565 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
566 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
567 rc
= cifs_push_posix_locks(cfile
);
569 rc
= tcon
->ses
->server
->ops
->push_mand_locks(cfile
);
571 up_write(&cinode
->lock_sem
);
576 cifs_reopen_file(struct cifsFileInfo
*cfile
, bool can_flush
)
581 struct cifs_sb_info
*cifs_sb
;
582 struct cifs_tcon
*tcon
;
583 struct TCP_Server_Info
*server
;
584 struct cifsInodeInfo
*cinode
;
586 char *full_path
= NULL
;
588 int disposition
= FILE_OPEN
;
589 int create_options
= CREATE_NOT_DIR
;
593 mutex_lock(&cfile
->fh_mutex
);
594 if (!cfile
->invalidHandle
) {
595 mutex_unlock(&cfile
->fh_mutex
);
601 inode
= cfile
->dentry
->d_inode
;
602 cifs_sb
= CIFS_SB(inode
->i_sb
);
603 tcon
= tlink_tcon(cfile
->tlink
);
604 server
= tcon
->ses
->server
;
607 * Can not grab rename sem here because various ops, including those
608 * that already have the rename sem can end up causing writepage to get
609 * called and if the server was down that means we end up here, and we
610 * can never tell if the caller already has the rename_sem.
612 full_path
= build_path_from_dentry(cfile
->dentry
);
613 if (full_path
== NULL
) {
615 mutex_unlock(&cfile
->fh_mutex
);
620 cFYI(1, "inode = 0x%p file flags 0x%x for %s", inode
, cfile
->f_flags
,
623 if (tcon
->ses
->server
->oplocks
)
628 if (tcon
->unix_ext
&& cap_unix(tcon
->ses
) &&
629 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
630 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
632 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
633 * original open. Must mask them off for a reopen.
635 unsigned int oflags
= cfile
->f_flags
&
636 ~(O_CREAT
| O_EXCL
| O_TRUNC
);
638 rc
= cifs_posix_open(full_path
, NULL
, inode
->i_sb
,
639 cifs_sb
->mnt_file_mode
/* ignored */,
640 oflags
, &oplock
, &fid
.netfid
, xid
);
642 cFYI(1, "posix reopen succeeded");
646 * fallthrough to retry open the old way on errors, especially
647 * in the reconnect path it is important to retry hard
651 desired_access
= cifs_convert_flags(cfile
->f_flags
);
653 if (backup_cred(cifs_sb
))
654 create_options
|= CREATE_OPEN_BACKUP_INTENT
;
656 if (server
->ops
->get_lease_key
)
657 server
->ops
->get_lease_key(inode
, &fid
);
660 * Can not refresh inode by passing in file_info buf to be returned by
661 * CIFSSMBOpen and then calling get_inode_info with returned buf since
662 * file might have write behind data that needs to be flushed and server
663 * version of file size can be stale. If we knew for sure that inode was
664 * not dirty locally we could do this.
666 rc
= server
->ops
->open(xid
, tcon
, full_path
, disposition
,
667 desired_access
, create_options
, &fid
, &oplock
,
670 mutex_unlock(&cfile
->fh_mutex
);
671 cFYI(1, "cifs_reopen returned 0x%x", rc
);
672 cFYI(1, "oplock: %d", oplock
);
673 goto reopen_error_exit
;
677 cfile
->invalidHandle
= false;
678 mutex_unlock(&cfile
->fh_mutex
);
679 cinode
= CIFS_I(inode
);
682 rc
= filemap_write_and_wait(inode
->i_mapping
);
683 mapping_set_error(inode
->i_mapping
, rc
);
686 rc
= cifs_get_inode_info_unix(&inode
, full_path
,
689 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
,
690 inode
->i_sb
, xid
, NULL
);
693 * Else we are writing out data to server already and could deadlock if
694 * we tried to flush data, and since we do not know if we have data that
695 * would invalidate the current end of file on the server we can not go
696 * to the server to get the new inode info.
699 server
->ops
->set_fid(cfile
, &fid
, oplock
);
700 cifs_relock_file(cfile
);
708 int cifs_close(struct inode
*inode
, struct file
*file
)
710 if (file
->private_data
!= NULL
) {
711 cifsFileInfo_put(file
->private_data
);
712 file
->private_data
= NULL
;
715 /* return code from the ->release op is always ignored */
719 int cifs_closedir(struct inode
*inode
, struct file
*file
)
723 struct cifsFileInfo
*cfile
= file
->private_data
;
724 struct cifs_tcon
*tcon
;
725 struct TCP_Server_Info
*server
;
728 cFYI(1, "Closedir inode = 0x%p", inode
);
734 tcon
= tlink_tcon(cfile
->tlink
);
735 server
= tcon
->ses
->server
;
737 cFYI(1, "Freeing private data in close dir");
738 spin_lock(&cifs_file_list_lock
);
739 if (!cfile
->srch_inf
.endOfSearch
&& !cfile
->invalidHandle
) {
740 cfile
->invalidHandle
= true;
741 spin_unlock(&cifs_file_list_lock
);
742 if (server
->ops
->close_dir
)
743 rc
= server
->ops
->close_dir(xid
, tcon
, &cfile
->fid
);
746 cFYI(1, "Closing uncompleted readdir with rc %d", rc
);
747 /* not much we can do if it fails anyway, ignore rc */
750 spin_unlock(&cifs_file_list_lock
);
752 buf
= cfile
->srch_inf
.ntwrk_buf_start
;
754 cFYI(1, "closedir free smb buf in srch struct");
755 cfile
->srch_inf
.ntwrk_buf_start
= NULL
;
756 if (cfile
->srch_inf
.smallBuf
)
757 cifs_small_buf_release(buf
);
759 cifs_buf_release(buf
);
762 cifs_put_tlink(cfile
->tlink
);
763 kfree(file
->private_data
);
764 file
->private_data
= NULL
;
765 /* BB can we lock the filestruct while this is going on? */
770 static struct cifsLockInfo
*
771 cifs_lock_init(__u64 offset
, __u64 length
, __u8 type
)
773 struct cifsLockInfo
*lock
=
774 kmalloc(sizeof(struct cifsLockInfo
), GFP_KERNEL
);
777 lock
->offset
= offset
;
778 lock
->length
= length
;
780 lock
->pid
= current
->tgid
;
781 INIT_LIST_HEAD(&lock
->blist
);
782 init_waitqueue_head(&lock
->block_q
);
787 cifs_del_lock_waiters(struct cifsLockInfo
*lock
)
789 struct cifsLockInfo
*li
, *tmp
;
790 list_for_each_entry_safe(li
, tmp
, &lock
->blist
, blist
) {
791 list_del_init(&li
->blist
);
792 wake_up(&li
->block_q
);
796 #define CIFS_LOCK_OP 0
797 #define CIFS_READ_OP 1
798 #define CIFS_WRITE_OP 2
800 /* @rw_check : 0 - no op, 1 - read, 2 - write */
802 cifs_find_fid_lock_conflict(struct cifs_fid_locks
*fdlocks
, __u64 offset
,
803 __u64 length
, __u8 type
, struct cifsFileInfo
*cfile
,
804 struct cifsLockInfo
**conf_lock
, int rw_check
)
806 struct cifsLockInfo
*li
;
807 struct cifsFileInfo
*cur_cfile
= fdlocks
->cfile
;
808 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
810 list_for_each_entry(li
, &fdlocks
->locks
, llist
) {
811 if (offset
+ length
<= li
->offset
||
812 offset
>= li
->offset
+ li
->length
)
814 if (rw_check
!= CIFS_LOCK_OP
&& current
->tgid
== li
->pid
&&
815 server
->ops
->compare_fids(cfile
, cur_cfile
)) {
816 /* shared lock prevents write op through the same fid */
817 if (!(li
->type
& server
->vals
->shared_lock_type
) ||
818 rw_check
!= CIFS_WRITE_OP
)
821 if ((type
& server
->vals
->shared_lock_type
) &&
822 ((server
->ops
->compare_fids(cfile
, cur_cfile
) &&
823 current
->tgid
== li
->pid
) || type
== li
->type
))
833 cifs_find_lock_conflict(struct cifsFileInfo
*cfile
, __u64 offset
, __u64 length
,
834 __u8 type
, struct cifsLockInfo
**conf_lock
,
838 struct cifs_fid_locks
*cur
;
839 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
841 list_for_each_entry(cur
, &cinode
->llist
, llist
) {
842 rc
= cifs_find_fid_lock_conflict(cur
, offset
, length
, type
,
843 cfile
, conf_lock
, rw_check
);
852 * Check if there is another lock that prevents us to set the lock (mandatory
853 * style). If such a lock exists, update the flock structure with its
854 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
855 * or leave it the same if we can't. Returns 0 if we don't need to request to
856 * the server or 1 otherwise.
859 cifs_lock_test(struct cifsFileInfo
*cfile
, __u64 offset
, __u64 length
,
860 __u8 type
, struct file_lock
*flock
)
863 struct cifsLockInfo
*conf_lock
;
864 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
865 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
868 down_read(&cinode
->lock_sem
);
870 exist
= cifs_find_lock_conflict(cfile
, offset
, length
, type
,
871 &conf_lock
, CIFS_LOCK_OP
);
873 flock
->fl_start
= conf_lock
->offset
;
874 flock
->fl_end
= conf_lock
->offset
+ conf_lock
->length
- 1;
875 flock
->fl_pid
= conf_lock
->pid
;
876 if (conf_lock
->type
& server
->vals
->shared_lock_type
)
877 flock
->fl_type
= F_RDLCK
;
879 flock
->fl_type
= F_WRLCK
;
880 } else if (!cinode
->can_cache_brlcks
)
883 flock
->fl_type
= F_UNLCK
;
885 up_read(&cinode
->lock_sem
);
890 cifs_lock_add(struct cifsFileInfo
*cfile
, struct cifsLockInfo
*lock
)
892 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
893 down_write(&cinode
->lock_sem
);
894 list_add_tail(&lock
->llist
, &cfile
->llist
->locks
);
895 up_write(&cinode
->lock_sem
);
899 * Set the byte-range lock (mandatory style). Returns:
900 * 1) 0, if we set the lock and don't need to request to the server;
901 * 2) 1, if no locks prevent us but we need to request to the server;
902 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
905 cifs_lock_add_if(struct cifsFileInfo
*cfile
, struct cifsLockInfo
*lock
,
908 struct cifsLockInfo
*conf_lock
;
909 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
915 down_write(&cinode
->lock_sem
);
917 exist
= cifs_find_lock_conflict(cfile
, lock
->offset
, lock
->length
,
918 lock
->type
, &conf_lock
, CIFS_LOCK_OP
);
919 if (!exist
&& cinode
->can_cache_brlcks
) {
920 list_add_tail(&lock
->llist
, &cfile
->llist
->locks
);
921 up_write(&cinode
->lock_sem
);
930 list_add_tail(&lock
->blist
, &conf_lock
->blist
);
931 up_write(&cinode
->lock_sem
);
932 rc
= wait_event_interruptible(lock
->block_q
,
933 (lock
->blist
.prev
== &lock
->blist
) &&
934 (lock
->blist
.next
== &lock
->blist
));
937 down_write(&cinode
->lock_sem
);
938 list_del_init(&lock
->blist
);
941 up_write(&cinode
->lock_sem
);
946 * Check if there is another lock that prevents us to set the lock (posix
947 * style). If such a lock exists, update the flock structure with its
948 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
949 * or leave it the same if we can't. Returns 0 if we don't need to request to
950 * the server or 1 otherwise.
953 cifs_posix_lock_test(struct file
*file
, struct file_lock
*flock
)
956 struct cifsInodeInfo
*cinode
= CIFS_I(file_inode(file
));
957 unsigned char saved_type
= flock
->fl_type
;
959 if ((flock
->fl_flags
& FL_POSIX
) == 0)
962 down_read(&cinode
->lock_sem
);
963 posix_test_lock(file
, flock
);
965 if (flock
->fl_type
== F_UNLCK
&& !cinode
->can_cache_brlcks
) {
966 flock
->fl_type
= saved_type
;
970 up_read(&cinode
->lock_sem
);
975 * Set the byte-range lock (posix style). Returns:
976 * 1) 0, if we set the lock and don't need to request to the server;
977 * 2) 1, if we need to request to the server;
978 * 3) <0, if the error occurs while setting the lock.
981 cifs_posix_lock_set(struct file
*file
, struct file_lock
*flock
)
983 struct cifsInodeInfo
*cinode
= CIFS_I(file_inode(file
));
986 if ((flock
->fl_flags
& FL_POSIX
) == 0)
990 down_write(&cinode
->lock_sem
);
991 if (!cinode
->can_cache_brlcks
) {
992 up_write(&cinode
->lock_sem
);
996 rc
= posix_lock_file(file
, flock
, NULL
);
997 up_write(&cinode
->lock_sem
);
998 if (rc
== FILE_LOCK_DEFERRED
) {
999 rc
= wait_event_interruptible(flock
->fl_wait
, !flock
->fl_next
);
1002 locks_delete_block(flock
);
1008 cifs_push_mandatory_locks(struct cifsFileInfo
*cfile
)
1011 int rc
= 0, stored_rc
;
1012 struct cifsLockInfo
*li
, *tmp
;
1013 struct cifs_tcon
*tcon
;
1014 unsigned int num
, max_num
, max_buf
;
1015 LOCKING_ANDX_RANGE
*buf
, *cur
;
1016 int types
[] = {LOCKING_ANDX_LARGE_FILES
,
1017 LOCKING_ANDX_SHARED_LOCK
| LOCKING_ANDX_LARGE_FILES
};
1021 tcon
= tlink_tcon(cfile
->tlink
);
1024 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1025 * and check it for zero before using.
1027 max_buf
= tcon
->ses
->server
->maxBuf
;
1033 max_num
= (max_buf
- sizeof(struct smb_hdr
)) /
1034 sizeof(LOCKING_ANDX_RANGE
);
1035 buf
= kzalloc(max_num
* sizeof(LOCKING_ANDX_RANGE
), GFP_KERNEL
);
1041 for (i
= 0; i
< 2; i
++) {
1044 list_for_each_entry_safe(li
, tmp
, &cfile
->llist
->locks
, llist
) {
1045 if (li
->type
!= types
[i
])
1047 cur
->Pid
= cpu_to_le16(li
->pid
);
1048 cur
->LengthLow
= cpu_to_le32((u32
)li
->length
);
1049 cur
->LengthHigh
= cpu_to_le32((u32
)(li
->length
>>32));
1050 cur
->OffsetLow
= cpu_to_le32((u32
)li
->offset
);
1051 cur
->OffsetHigh
= cpu_to_le32((u32
)(li
->offset
>>32));
1052 if (++num
== max_num
) {
1053 stored_rc
= cifs_lockv(xid
, tcon
,
1055 (__u8
)li
->type
, 0, num
,
1066 stored_rc
= cifs_lockv(xid
, tcon
, cfile
->fid
.netfid
,
1067 (__u8
)types
[i
], 0, num
, buf
);
1078 /* copied from fs/locks.c with a name change */
1079 #define cifs_for_each_lock(inode, lockp) \
1080 for (lockp = &inode->i_flock; *lockp != NULL; \
1081 lockp = &(*lockp)->fl_next)
1083 struct lock_to_push
{
1084 struct list_head llist
;
1093 cifs_push_posix_locks(struct cifsFileInfo
*cfile
)
1095 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1096 struct file_lock
*flock
, **before
;
1097 unsigned int count
= 0, i
= 0;
1098 int rc
= 0, xid
, type
;
1099 struct list_head locks_to_send
, *el
;
1100 struct lock_to_push
*lck
, *tmp
;
1106 cifs_for_each_lock(cfile
->dentry
->d_inode
, before
) {
1107 if ((*before
)->fl_flags
& FL_POSIX
)
1112 INIT_LIST_HEAD(&locks_to_send
);
1115 * Allocating count locks is enough because no FL_POSIX locks can be
1116 * added to the list while we are holding cinode->lock_sem that
1117 * protects locking operations of this inode.
1119 for (; i
< count
; i
++) {
1120 lck
= kmalloc(sizeof(struct lock_to_push
), GFP_KERNEL
);
1125 list_add_tail(&lck
->llist
, &locks_to_send
);
1128 el
= locks_to_send
.next
;
1130 cifs_for_each_lock(cfile
->dentry
->d_inode
, before
) {
1132 if ((flock
->fl_flags
& FL_POSIX
) == 0)
1134 if (el
== &locks_to_send
) {
1136 * The list ended. We don't have enough allocated
1137 * structures - something is really wrong.
1139 cERROR(1, "Can't push all brlocks!");
1142 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1143 if (flock
->fl_type
== F_RDLCK
|| flock
->fl_type
== F_SHLCK
)
1147 lck
= list_entry(el
, struct lock_to_push
, llist
);
1148 lck
->pid
= flock
->fl_pid
;
1149 lck
->netfid
= cfile
->fid
.netfid
;
1150 lck
->length
= length
;
1152 lck
->offset
= flock
->fl_start
;
1157 list_for_each_entry_safe(lck
, tmp
, &locks_to_send
, llist
) {
1160 stored_rc
= CIFSSMBPosixLock(xid
, tcon
, lck
->netfid
, lck
->pid
,
1161 lck
->offset
, lck
->length
, NULL
,
1165 list_del(&lck
->llist
);
1173 list_for_each_entry_safe(lck
, tmp
, &locks_to_send
, llist
) {
1174 list_del(&lck
->llist
);
1181 cifs_push_locks(struct cifsFileInfo
*cfile
)
1183 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->dentry
->d_sb
);
1184 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
1185 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1188 /* we are going to update can_cache_brlcks here - need a write access */
1189 down_write(&cinode
->lock_sem
);
1190 if (!cinode
->can_cache_brlcks
) {
1191 up_write(&cinode
->lock_sem
);
1195 if (cap_unix(tcon
->ses
) &&
1196 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
1197 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
1198 rc
= cifs_push_posix_locks(cfile
);
1200 rc
= tcon
->ses
->server
->ops
->push_mand_locks(cfile
);
1202 cinode
->can_cache_brlcks
= false;
1203 up_write(&cinode
->lock_sem
);
1208 cifs_read_flock(struct file_lock
*flock
, __u32
*type
, int *lock
, int *unlock
,
1209 bool *wait_flag
, struct TCP_Server_Info
*server
)
1211 if (flock
->fl_flags
& FL_POSIX
)
1213 if (flock
->fl_flags
& FL_FLOCK
)
1215 if (flock
->fl_flags
& FL_SLEEP
) {
1216 cFYI(1, "Blocking lock");
1219 if (flock
->fl_flags
& FL_ACCESS
)
1220 cFYI(1, "Process suspended by mandatory locking - "
1221 "not implemented yet");
1222 if (flock
->fl_flags
& FL_LEASE
)
1223 cFYI(1, "Lease on file - not implemented yet");
1224 if (flock
->fl_flags
&
1225 (~(FL_POSIX
| FL_FLOCK
| FL_SLEEP
|
1226 FL_ACCESS
| FL_LEASE
| FL_CLOSE
)))
1227 cFYI(1, "Unknown lock flags 0x%x", flock
->fl_flags
);
1229 *type
= server
->vals
->large_lock_type
;
1230 if (flock
->fl_type
== F_WRLCK
) {
1231 cFYI(1, "F_WRLCK ");
1232 *type
|= server
->vals
->exclusive_lock_type
;
1234 } else if (flock
->fl_type
== F_UNLCK
) {
1236 *type
|= server
->vals
->unlock_lock_type
;
1238 /* Check if unlock includes more than one lock range */
1239 } else if (flock
->fl_type
== F_RDLCK
) {
1241 *type
|= server
->vals
->shared_lock_type
;
1243 } else if (flock
->fl_type
== F_EXLCK
) {
1245 *type
|= server
->vals
->exclusive_lock_type
;
1247 } else if (flock
->fl_type
== F_SHLCK
) {
1249 *type
|= server
->vals
->shared_lock_type
;
1252 cFYI(1, "Unknown type of lock");
1256 cifs_getlk(struct file
*file
, struct file_lock
*flock
, __u32 type
,
1257 bool wait_flag
, bool posix_lck
, unsigned int xid
)
1260 __u64 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1261 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)file
->private_data
;
1262 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1263 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1264 __u16 netfid
= cfile
->fid
.netfid
;
1267 int posix_lock_type
;
1269 rc
= cifs_posix_lock_test(file
, flock
);
1273 if (type
& server
->vals
->shared_lock_type
)
1274 posix_lock_type
= CIFS_RDLCK
;
1276 posix_lock_type
= CIFS_WRLCK
;
1277 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, current
->tgid
,
1278 flock
->fl_start
, length
, flock
,
1279 posix_lock_type
, wait_flag
);
1283 rc
= cifs_lock_test(cfile
, flock
->fl_start
, length
, type
, flock
);
1287 /* BB we could chain these into one lock request BB */
1288 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
, type
,
1291 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
,
1293 flock
->fl_type
= F_UNLCK
;
1295 cERROR(1, "Error unlocking previously locked "
1296 "range %d during test of lock", rc
);
1300 if (type
& server
->vals
->shared_lock_type
) {
1301 flock
->fl_type
= F_WRLCK
;
1305 type
&= ~server
->vals
->exclusive_lock_type
;
1307 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
,
1308 type
| server
->vals
->shared_lock_type
,
1311 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
,
1312 type
| server
->vals
->shared_lock_type
, 0, 1, false);
1313 flock
->fl_type
= F_RDLCK
;
1315 cERROR(1, "Error unlocking previously locked "
1316 "range %d during test of lock", rc
);
1318 flock
->fl_type
= F_WRLCK
;
1324 cifs_move_llist(struct list_head
*source
, struct list_head
*dest
)
1326 struct list_head
*li
, *tmp
;
1327 list_for_each_safe(li
, tmp
, source
)
1328 list_move(li
, dest
);
1332 cifs_free_llist(struct list_head
*llist
)
1334 struct cifsLockInfo
*li
, *tmp
;
1335 list_for_each_entry_safe(li
, tmp
, llist
, llist
) {
1336 cifs_del_lock_waiters(li
);
1337 list_del(&li
->llist
);
1343 cifs_unlock_range(struct cifsFileInfo
*cfile
, struct file_lock
*flock
,
1346 int rc
= 0, stored_rc
;
1347 int types
[] = {LOCKING_ANDX_LARGE_FILES
,
1348 LOCKING_ANDX_SHARED_LOCK
| LOCKING_ANDX_LARGE_FILES
};
1350 unsigned int max_num
, num
, max_buf
;
1351 LOCKING_ANDX_RANGE
*buf
, *cur
;
1352 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1353 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
1354 struct cifsLockInfo
*li
, *tmp
;
1355 __u64 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1356 struct list_head tmp_llist
;
1358 INIT_LIST_HEAD(&tmp_llist
);
1361 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1362 * and check it for zero before using.
1364 max_buf
= tcon
->ses
->server
->maxBuf
;
1368 max_num
= (max_buf
- sizeof(struct smb_hdr
)) /
1369 sizeof(LOCKING_ANDX_RANGE
);
1370 buf
= kzalloc(max_num
* sizeof(LOCKING_ANDX_RANGE
), GFP_KERNEL
);
1374 down_write(&cinode
->lock_sem
);
1375 for (i
= 0; i
< 2; i
++) {
1378 list_for_each_entry_safe(li
, tmp
, &cfile
->llist
->locks
, llist
) {
1379 if (flock
->fl_start
> li
->offset
||
1380 (flock
->fl_start
+ length
) <
1381 (li
->offset
+ li
->length
))
1383 if (current
->tgid
!= li
->pid
)
1385 if (types
[i
] != li
->type
)
1387 if (cinode
->can_cache_brlcks
) {
1389 * We can cache brlock requests - simply remove
1390 * a lock from the file's list.
1392 list_del(&li
->llist
);
1393 cifs_del_lock_waiters(li
);
1397 cur
->Pid
= cpu_to_le16(li
->pid
);
1398 cur
->LengthLow
= cpu_to_le32((u32
)li
->length
);
1399 cur
->LengthHigh
= cpu_to_le32((u32
)(li
->length
>>32));
1400 cur
->OffsetLow
= cpu_to_le32((u32
)li
->offset
);
1401 cur
->OffsetHigh
= cpu_to_le32((u32
)(li
->offset
>>32));
1403 * We need to save a lock here to let us add it again to
1404 * the file's list if the unlock range request fails on
1407 list_move(&li
->llist
, &tmp_llist
);
1408 if (++num
== max_num
) {
1409 stored_rc
= cifs_lockv(xid
, tcon
,
1411 li
->type
, num
, 0, buf
);
1414 * We failed on the unlock range
1415 * request - add all locks from the tmp
1416 * list to the head of the file's list.
1418 cifs_move_llist(&tmp_llist
,
1419 &cfile
->llist
->locks
);
1423 * The unlock range request succeed -
1424 * free the tmp list.
1426 cifs_free_llist(&tmp_llist
);
1433 stored_rc
= cifs_lockv(xid
, tcon
, cfile
->fid
.netfid
,
1434 types
[i
], num
, 0, buf
);
1436 cifs_move_llist(&tmp_llist
,
1437 &cfile
->llist
->locks
);
1440 cifs_free_llist(&tmp_llist
);
1444 up_write(&cinode
->lock_sem
);
1450 cifs_setlk(struct file
*file
, struct file_lock
*flock
, __u32 type
,
1451 bool wait_flag
, bool posix_lck
, int lock
, int unlock
,
1455 __u64 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1456 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)file
->private_data
;
1457 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1458 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1459 struct inode
*inode
= cfile
->dentry
->d_inode
;
1462 int posix_lock_type
;
1464 rc
= cifs_posix_lock_set(file
, flock
);
1468 if (type
& server
->vals
->shared_lock_type
)
1469 posix_lock_type
= CIFS_RDLCK
;
1471 posix_lock_type
= CIFS_WRLCK
;
1474 posix_lock_type
= CIFS_UNLCK
;
1476 rc
= CIFSSMBPosixLock(xid
, tcon
, cfile
->fid
.netfid
,
1477 current
->tgid
, flock
->fl_start
, length
,
1478 NULL
, posix_lock_type
, wait_flag
);
1483 struct cifsLockInfo
*lock
;
1485 lock
= cifs_lock_init(flock
->fl_start
, length
, type
);
1489 rc
= cifs_lock_add_if(cfile
, lock
, wait_flag
);
1498 * Windows 7 server can delay breaking lease from read to None
1499 * if we set a byte-range lock on a file - break it explicitly
1500 * before sending the lock to the server to be sure the next
1501 * read won't conflict with non-overlapted locks due to
1504 if (!CIFS_I(inode
)->clientCanCacheAll
&&
1505 CIFS_I(inode
)->clientCanCacheRead
) {
1506 cifs_invalidate_mapping(inode
);
1507 cFYI(1, "Set no oplock for inode=%p due to mand locks",
1509 CIFS_I(inode
)->clientCanCacheRead
= false;
1512 rc
= server
->ops
->mand_lock(xid
, cfile
, flock
->fl_start
, length
,
1513 type
, 1, 0, wait_flag
);
1519 cifs_lock_add(cfile
, lock
);
1521 rc
= server
->ops
->mand_unlock_range(cfile
, flock
, xid
);
1524 if (flock
->fl_flags
& FL_POSIX
)
1525 posix_lock_file_wait(file
, flock
);
1529 int cifs_lock(struct file
*file
, int cmd
, struct file_lock
*flock
)
1532 int lock
= 0, unlock
= 0;
1533 bool wait_flag
= false;
1534 bool posix_lck
= false;
1535 struct cifs_sb_info
*cifs_sb
;
1536 struct cifs_tcon
*tcon
;
1537 struct cifsInodeInfo
*cinode
;
1538 struct cifsFileInfo
*cfile
;
1545 cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1546 "end: %lld", cmd
, flock
->fl_flags
, flock
->fl_type
,
1547 flock
->fl_start
, flock
->fl_end
);
1549 cfile
= (struct cifsFileInfo
*)file
->private_data
;
1550 tcon
= tlink_tcon(cfile
->tlink
);
1552 cifs_read_flock(flock
, &type
, &lock
, &unlock
, &wait_flag
,
1555 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1556 netfid
= cfile
->fid
.netfid
;
1557 cinode
= CIFS_I(file_inode(file
));
1559 if (cap_unix(tcon
->ses
) &&
1560 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
1561 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
1564 * BB add code here to normalize offset and length to account for
1565 * negative length which we can not accept over the wire.
1567 if (IS_GETLK(cmd
)) {
1568 rc
= cifs_getlk(file
, flock
, type
, wait_flag
, posix_lck
, xid
);
1573 if (!lock
&& !unlock
) {
1575 * if no lock or unlock then nothing to do since we do not
1582 rc
= cifs_setlk(file
, flock
, type
, wait_flag
, posix_lck
, lock
, unlock
,
1589 * update the file size (if needed) after a write. Should be called with
1590 * the inode->i_lock held
1593 cifs_update_eof(struct cifsInodeInfo
*cifsi
, loff_t offset
,
1594 unsigned int bytes_written
)
1596 loff_t end_of_write
= offset
+ bytes_written
;
1598 if (end_of_write
> cifsi
->server_eof
)
1599 cifsi
->server_eof
= end_of_write
;
1603 cifs_write(struct cifsFileInfo
*open_file
, __u32 pid
, const char *write_data
,
1604 size_t write_size
, loff_t
*offset
)
1607 unsigned int bytes_written
= 0;
1608 unsigned int total_written
;
1609 struct cifs_sb_info
*cifs_sb
;
1610 struct cifs_tcon
*tcon
;
1611 struct TCP_Server_Info
*server
;
1613 struct dentry
*dentry
= open_file
->dentry
;
1614 struct cifsInodeInfo
*cifsi
= CIFS_I(dentry
->d_inode
);
1615 struct cifs_io_parms io_parms
;
1617 cifs_sb
= CIFS_SB(dentry
->d_sb
);
1619 cFYI(1, "write %zd bytes to offset %lld of %s", write_size
,
1620 *offset
, dentry
->d_name
.name
);
1622 tcon
= tlink_tcon(open_file
->tlink
);
1623 server
= tcon
->ses
->server
;
1625 if (!server
->ops
->sync_write
)
1630 for (total_written
= 0; write_size
> total_written
;
1631 total_written
+= bytes_written
) {
1633 while (rc
== -EAGAIN
) {
1637 if (open_file
->invalidHandle
) {
1638 /* we could deadlock if we called
1639 filemap_fdatawait from here so tell
1640 reopen_file not to flush data to
1642 rc
= cifs_reopen_file(open_file
, false);
1647 len
= min((size_t)cifs_sb
->wsize
,
1648 write_size
- total_written
);
1649 /* iov[0] is reserved for smb header */
1650 iov
[1].iov_base
= (char *)write_data
+ total_written
;
1651 iov
[1].iov_len
= len
;
1653 io_parms
.tcon
= tcon
;
1654 io_parms
.offset
= *offset
;
1655 io_parms
.length
= len
;
1656 rc
= server
->ops
->sync_write(xid
, open_file
, &io_parms
,
1657 &bytes_written
, iov
, 1);
1659 if (rc
|| (bytes_written
== 0)) {
1667 spin_lock(&dentry
->d_inode
->i_lock
);
1668 cifs_update_eof(cifsi
, *offset
, bytes_written
);
1669 spin_unlock(&dentry
->d_inode
->i_lock
);
1670 *offset
+= bytes_written
;
1674 cifs_stats_bytes_written(tcon
, total_written
);
1676 if (total_written
> 0) {
1677 spin_lock(&dentry
->d_inode
->i_lock
);
1678 if (*offset
> dentry
->d_inode
->i_size
)
1679 i_size_write(dentry
->d_inode
, *offset
);
1680 spin_unlock(&dentry
->d_inode
->i_lock
);
1682 mark_inode_dirty_sync(dentry
->d_inode
);
1684 return total_written
;
1687 struct cifsFileInfo
*find_readable_file(struct cifsInodeInfo
*cifs_inode
,
1690 struct cifsFileInfo
*open_file
= NULL
;
1691 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1693 /* only filter by fsuid on multiuser mounts */
1694 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1697 spin_lock(&cifs_file_list_lock
);
1698 /* we could simply get the first_list_entry since write-only entries
1699 are always at the end of the list but since the first entry might
1700 have a close pending, we go through the whole list */
1701 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1702 if (fsuid_only
&& !uid_eq(open_file
->uid
, current_fsuid()))
1704 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_READ
) {
1705 if (!open_file
->invalidHandle
) {
1706 /* found a good file */
1707 /* lock it so it will not be closed on us */
1708 cifsFileInfo_get_locked(open_file
);
1709 spin_unlock(&cifs_file_list_lock
);
1711 } /* else might as well continue, and look for
1712 another, or simply have the caller reopen it
1713 again rather than trying to fix this handle */
1714 } else /* write only file */
1715 break; /* write only files are last so must be done */
1717 spin_unlock(&cifs_file_list_lock
);
1721 struct cifsFileInfo
*find_writable_file(struct cifsInodeInfo
*cifs_inode
,
1724 struct cifsFileInfo
*open_file
, *inv_file
= NULL
;
1725 struct cifs_sb_info
*cifs_sb
;
1726 bool any_available
= false;
1728 unsigned int refind
= 0;
1730 /* Having a null inode here (because mapping->host was set to zero by
1731 the VFS or MM) should not happen but we had reports of on oops (due to
1732 it being zero) during stress testcases so we need to check for it */
1734 if (cifs_inode
== NULL
) {
1735 cERROR(1, "Null inode passed to cifs_writeable_file");
1740 cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1742 /* only filter by fsuid on multiuser mounts */
1743 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1746 spin_lock(&cifs_file_list_lock
);
1748 if (refind
> MAX_REOPEN_ATT
) {
1749 spin_unlock(&cifs_file_list_lock
);
1752 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1753 if (!any_available
&& open_file
->pid
!= current
->tgid
)
1755 if (fsuid_only
&& !uid_eq(open_file
->uid
, current_fsuid()))
1757 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_WRITE
) {
1758 if (!open_file
->invalidHandle
) {
1759 /* found a good writable file */
1760 cifsFileInfo_get_locked(open_file
);
1761 spin_unlock(&cifs_file_list_lock
);
1765 inv_file
= open_file
;
1769 /* couldn't find useable FH with same pid, try any available */
1770 if (!any_available
) {
1771 any_available
= true;
1772 goto refind_writable
;
1776 any_available
= false;
1777 cifsFileInfo_get_locked(inv_file
);
1780 spin_unlock(&cifs_file_list_lock
);
1783 rc
= cifs_reopen_file(inv_file
, false);
1787 spin_lock(&cifs_file_list_lock
);
1788 list_move_tail(&inv_file
->flist
,
1789 &cifs_inode
->openFileList
);
1790 spin_unlock(&cifs_file_list_lock
);
1791 cifsFileInfo_put(inv_file
);
1792 spin_lock(&cifs_file_list_lock
);
1794 goto refind_writable
;
1801 static int cifs_partialpagewrite(struct page
*page
, unsigned from
, unsigned to
)
1803 struct address_space
*mapping
= page
->mapping
;
1804 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1807 int bytes_written
= 0;
1808 struct inode
*inode
;
1809 struct cifsFileInfo
*open_file
;
1811 if (!mapping
|| !mapping
->host
)
1814 inode
= page
->mapping
->host
;
1816 offset
+= (loff_t
)from
;
1817 write_data
= kmap(page
);
1820 if ((to
> PAGE_CACHE_SIZE
) || (from
> to
)) {
1825 /* racing with truncate? */
1826 if (offset
> mapping
->host
->i_size
) {
1828 return 0; /* don't care */
1831 /* check to make sure that we are not extending the file */
1832 if (mapping
->host
->i_size
- offset
< (loff_t
)to
)
1833 to
= (unsigned)(mapping
->host
->i_size
- offset
);
1835 open_file
= find_writable_file(CIFS_I(mapping
->host
), false);
1837 bytes_written
= cifs_write(open_file
, open_file
->pid
,
1838 write_data
, to
- from
, &offset
);
1839 cifsFileInfo_put(open_file
);
1840 /* Does mm or vfs already set times? */
1841 inode
->i_atime
= inode
->i_mtime
= current_fs_time(inode
->i_sb
);
1842 if ((bytes_written
> 0) && (offset
))
1844 else if (bytes_written
< 0)
1847 cFYI(1, "No writeable filehandles for inode");
1855 static int cifs_writepages(struct address_space
*mapping
,
1856 struct writeback_control
*wbc
)
1858 struct cifs_sb_info
*cifs_sb
= CIFS_SB(mapping
->host
->i_sb
);
1859 bool done
= false, scanned
= false, range_whole
= false;
1861 struct cifs_writedata
*wdata
;
1862 struct TCP_Server_Info
*server
;
1867 * If wsize is smaller than the page cache size, default to writing
1868 * one page at a time via cifs_writepage
1870 if (cifs_sb
->wsize
< PAGE_CACHE_SIZE
)
1871 return generic_writepages(mapping
, wbc
);
1873 if (wbc
->range_cyclic
) {
1874 index
= mapping
->writeback_index
; /* Start from prev offset */
1877 index
= wbc
->range_start
>> PAGE_CACHE_SHIFT
;
1878 end
= wbc
->range_end
>> PAGE_CACHE_SHIFT
;
1879 if (wbc
->range_start
== 0 && wbc
->range_end
== LLONG_MAX
)
1884 while (!done
&& index
<= end
) {
1885 unsigned int i
, nr_pages
, found_pages
;
1886 pgoff_t next
= 0, tofind
;
1887 struct page
**pages
;
1889 tofind
= min((cifs_sb
->wsize
/ PAGE_CACHE_SIZE
) - 1,
1892 wdata
= cifs_writedata_alloc((unsigned int)tofind
,
1893 cifs_writev_complete
);
1900 * find_get_pages_tag seems to return a max of 256 on each
1901 * iteration, so we must call it several times in order to
1902 * fill the array or the wsize is effectively limited to
1903 * 256 * PAGE_CACHE_SIZE.
1906 pages
= wdata
->pages
;
1908 nr_pages
= find_get_pages_tag(mapping
, &index
,
1909 PAGECACHE_TAG_DIRTY
,
1911 found_pages
+= nr_pages
;
1914 } while (nr_pages
&& tofind
&& index
<= end
);
1916 if (found_pages
== 0) {
1917 kref_put(&wdata
->refcount
, cifs_writedata_release
);
1922 for (i
= 0; i
< found_pages
; i
++) {
1923 page
= wdata
->pages
[i
];
1925 * At this point we hold neither mapping->tree_lock nor
1926 * lock on the page itself: the page may be truncated or
1927 * invalidated (changing page->mapping to NULL), or even
1928 * swizzled back from swapper_space to tmpfs file
1934 else if (!trylock_page(page
))
1937 if (unlikely(page
->mapping
!= mapping
)) {
1942 if (!wbc
->range_cyclic
&& page
->index
> end
) {
1948 if (next
&& (page
->index
!= next
)) {
1949 /* Not next consecutive page */
1954 if (wbc
->sync_mode
!= WB_SYNC_NONE
)
1955 wait_on_page_writeback(page
);
1957 if (PageWriteback(page
) ||
1958 !clear_page_dirty_for_io(page
)) {
1964 * This actually clears the dirty bit in the radix tree.
1965 * See cifs_writepage() for more commentary.
1967 set_page_writeback(page
);
1969 if (page_offset(page
) >= i_size_read(mapping
->host
)) {
1972 end_page_writeback(page
);
1976 wdata
->pages
[i
] = page
;
1977 next
= page
->index
+ 1;
1981 /* reset index to refind any pages skipped */
1983 index
= wdata
->pages
[0]->index
+ 1;
1985 /* put any pages we aren't going to use */
1986 for (i
= nr_pages
; i
< found_pages
; i
++) {
1987 page_cache_release(wdata
->pages
[i
]);
1988 wdata
->pages
[i
] = NULL
;
1991 /* nothing to write? */
1992 if (nr_pages
== 0) {
1993 kref_put(&wdata
->refcount
, cifs_writedata_release
);
1997 wdata
->sync_mode
= wbc
->sync_mode
;
1998 wdata
->nr_pages
= nr_pages
;
1999 wdata
->offset
= page_offset(wdata
->pages
[0]);
2000 wdata
->pagesz
= PAGE_CACHE_SIZE
;
2002 min(i_size_read(mapping
->host
) -
2003 page_offset(wdata
->pages
[nr_pages
- 1]),
2004 (loff_t
)PAGE_CACHE_SIZE
);
2005 wdata
->bytes
= ((nr_pages
- 1) * PAGE_CACHE_SIZE
) +
2009 if (wdata
->cfile
!= NULL
)
2010 cifsFileInfo_put(wdata
->cfile
);
2011 wdata
->cfile
= find_writable_file(CIFS_I(mapping
->host
),
2013 if (!wdata
->cfile
) {
2014 cERROR(1, "No writable handles for inode");
2018 wdata
->pid
= wdata
->cfile
->pid
;
2019 server
= tlink_tcon(wdata
->cfile
->tlink
)->ses
->server
;
2020 rc
= server
->ops
->async_writev(wdata
);
2021 } while (wbc
->sync_mode
== WB_SYNC_ALL
&& rc
== -EAGAIN
);
2023 for (i
= 0; i
< nr_pages
; ++i
)
2024 unlock_page(wdata
->pages
[i
]);
2026 /* send failure -- clean up the mess */
2028 for (i
= 0; i
< nr_pages
; ++i
) {
2030 redirty_page_for_writepage(wbc
,
2033 SetPageError(wdata
->pages
[i
]);
2034 end_page_writeback(wdata
->pages
[i
]);
2035 page_cache_release(wdata
->pages
[i
]);
2038 mapping_set_error(mapping
, rc
);
2040 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2042 wbc
->nr_to_write
-= nr_pages
;
2043 if (wbc
->nr_to_write
<= 0)
2049 if (!scanned
&& !done
) {
2051 * We hit the last page and there is more work to be done: wrap
2052 * back to the start of the file
2059 if (wbc
->range_cyclic
|| (range_whole
&& wbc
->nr_to_write
> 0))
2060 mapping
->writeback_index
= index
;
2066 cifs_writepage_locked(struct page
*page
, struct writeback_control
*wbc
)
2072 /* BB add check for wbc flags */
2073 page_cache_get(page
);
2074 if (!PageUptodate(page
))
2075 cFYI(1, "ppw - page not up to date");
2078 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2080 * A writepage() implementation always needs to do either this,
2081 * or re-dirty the page with "redirty_page_for_writepage()" in
2082 * the case of a failure.
2084 * Just unlocking the page will cause the radix tree tag-bits
2085 * to fail to update with the state of the page correctly.
2087 set_page_writeback(page
);
2089 rc
= cifs_partialpagewrite(page
, 0, PAGE_CACHE_SIZE
);
2090 if (rc
== -EAGAIN
&& wbc
->sync_mode
== WB_SYNC_ALL
)
2092 else if (rc
== -EAGAIN
)
2093 redirty_page_for_writepage(wbc
, page
);
2097 SetPageUptodate(page
);
2098 end_page_writeback(page
);
2099 page_cache_release(page
);
2104 static int cifs_writepage(struct page
*page
, struct writeback_control
*wbc
)
2106 int rc
= cifs_writepage_locked(page
, wbc
);
2111 static int cifs_write_end(struct file
*file
, struct address_space
*mapping
,
2112 loff_t pos
, unsigned len
, unsigned copied
,
2113 struct page
*page
, void *fsdata
)
2116 struct inode
*inode
= mapping
->host
;
2117 struct cifsFileInfo
*cfile
= file
->private_data
;
2118 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->dentry
->d_sb
);
2121 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
2124 pid
= current
->tgid
;
2126 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
2129 if (PageChecked(page
)) {
2131 SetPageUptodate(page
);
2132 ClearPageChecked(page
);
2133 } else if (!PageUptodate(page
) && copied
== PAGE_CACHE_SIZE
)
2134 SetPageUptodate(page
);
2136 if (!PageUptodate(page
)) {
2138 unsigned offset
= pos
& (PAGE_CACHE_SIZE
- 1);
2142 /* this is probably better than directly calling
2143 partialpage_write since in this function the file handle is
2144 known which we might as well leverage */
2145 /* BB check if anything else missing out of ppw
2146 such as updating last write time */
2147 page_data
= kmap(page
);
2148 rc
= cifs_write(cfile
, pid
, page_data
+ offset
, copied
, &pos
);
2149 /* if (rc < 0) should we set writebehind rc? */
2156 set_page_dirty(page
);
2160 spin_lock(&inode
->i_lock
);
2161 if (pos
> inode
->i_size
)
2162 i_size_write(inode
, pos
);
2163 spin_unlock(&inode
->i_lock
);
2167 page_cache_release(page
);
2172 int cifs_strict_fsync(struct file
*file
, loff_t start
, loff_t end
,
2177 struct cifs_tcon
*tcon
;
2178 struct TCP_Server_Info
*server
;
2179 struct cifsFileInfo
*smbfile
= file
->private_data
;
2180 struct inode
*inode
= file_inode(file
);
2181 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2183 rc
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
2186 mutex_lock(&inode
->i_mutex
);
2190 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2191 file
->f_path
.dentry
->d_name
.name
, datasync
);
2193 if (!CIFS_I(inode
)->clientCanCacheRead
) {
2194 rc
= cifs_invalidate_mapping(inode
);
2196 cFYI(1, "rc: %d during invalidate phase", rc
);
2197 rc
= 0; /* don't care about it in fsync */
2201 tcon
= tlink_tcon(smbfile
->tlink
);
2202 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
)) {
2203 server
= tcon
->ses
->server
;
2204 if (server
->ops
->flush
)
2205 rc
= server
->ops
->flush(xid
, tcon
, &smbfile
->fid
);
2211 mutex_unlock(&inode
->i_mutex
);
2215 int cifs_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
2219 struct cifs_tcon
*tcon
;
2220 struct TCP_Server_Info
*server
;
2221 struct cifsFileInfo
*smbfile
= file
->private_data
;
2222 struct cifs_sb_info
*cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
2223 struct inode
*inode
= file
->f_mapping
->host
;
2225 rc
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
2228 mutex_lock(&inode
->i_mutex
);
2232 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2233 file
->f_path
.dentry
->d_name
.name
, datasync
);
2235 tcon
= tlink_tcon(smbfile
->tlink
);
2236 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
)) {
2237 server
= tcon
->ses
->server
;
2238 if (server
->ops
->flush
)
2239 rc
= server
->ops
->flush(xid
, tcon
, &smbfile
->fid
);
2245 mutex_unlock(&inode
->i_mutex
);
2250 * As file closes, flush all cached write data for this inode checking
2251 * for write behind errors.
2253 int cifs_flush(struct file
*file
, fl_owner_t id
)
2255 struct inode
*inode
= file_inode(file
);
2258 if (file
->f_mode
& FMODE_WRITE
)
2259 rc
= filemap_write_and_wait(inode
->i_mapping
);
2261 cFYI(1, "Flush inode %p file %p rc %d", inode
, file
, rc
);
2267 cifs_write_allocate_pages(struct page
**pages
, unsigned long num_pages
)
2272 for (i
= 0; i
< num_pages
; i
++) {
2273 pages
[i
] = alloc_page(GFP_KERNEL
|__GFP_HIGHMEM
);
2276 * save number of pages we have already allocated and
2277 * return with ENOMEM error
2286 for (i
= 0; i
< num_pages
; i
++)
2293 size_t get_numpages(const size_t wsize
, const size_t len
, size_t *cur_len
)
2298 clen
= min_t(const size_t, len
, wsize
);
2299 num_pages
= DIV_ROUND_UP(clen
, PAGE_SIZE
);
2308 cifs_uncached_writev_complete(struct work_struct
*work
)
2311 struct cifs_writedata
*wdata
= container_of(work
,
2312 struct cifs_writedata
, work
);
2313 struct inode
*inode
= wdata
->cfile
->dentry
->d_inode
;
2314 struct cifsInodeInfo
*cifsi
= CIFS_I(inode
);
2316 spin_lock(&inode
->i_lock
);
2317 cifs_update_eof(cifsi
, wdata
->offset
, wdata
->bytes
);
2318 if (cifsi
->server_eof
> inode
->i_size
)
2319 i_size_write(inode
, cifsi
->server_eof
);
2320 spin_unlock(&inode
->i_lock
);
2322 complete(&wdata
->done
);
2324 if (wdata
->result
!= -EAGAIN
) {
2325 for (i
= 0; i
< wdata
->nr_pages
; i
++)
2326 put_page(wdata
->pages
[i
]);
2329 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2332 /* attempt to send write to server, retry on any -EAGAIN errors */
2334 cifs_uncached_retry_writev(struct cifs_writedata
*wdata
)
2337 struct TCP_Server_Info
*server
;
2339 server
= tlink_tcon(wdata
->cfile
->tlink
)->ses
->server
;
2342 if (wdata
->cfile
->invalidHandle
) {
2343 rc
= cifs_reopen_file(wdata
->cfile
, false);
2347 rc
= server
->ops
->async_writev(wdata
);
2348 } while (rc
== -EAGAIN
);
2354 cifs_iovec_write(struct file
*file
, const struct iovec
*iov
,
2355 unsigned long nr_segs
, loff_t
*poffset
)
2357 unsigned long nr_pages
, i
;
2358 size_t copied
, len
, cur_len
;
2359 ssize_t total_written
= 0;
2362 struct cifsFileInfo
*open_file
;
2363 struct cifs_tcon
*tcon
;
2364 struct cifs_sb_info
*cifs_sb
;
2365 struct cifs_writedata
*wdata
, *tmp
;
2366 struct list_head wdata_list
;
2370 len
= iov_length(iov
, nr_segs
);
2374 rc
= generic_write_checks(file
, poffset
, &len
, 0);
2378 INIT_LIST_HEAD(&wdata_list
);
2379 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
2380 open_file
= file
->private_data
;
2381 tcon
= tlink_tcon(open_file
->tlink
);
2383 if (!tcon
->ses
->server
->ops
->async_writev
)
2388 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
2389 pid
= open_file
->pid
;
2391 pid
= current
->tgid
;
2393 iov_iter_init(&it
, iov
, nr_segs
, len
, 0);
2397 nr_pages
= get_numpages(cifs_sb
->wsize
, len
, &cur_len
);
2398 wdata
= cifs_writedata_alloc(nr_pages
,
2399 cifs_uncached_writev_complete
);
2405 rc
= cifs_write_allocate_pages(wdata
->pages
, nr_pages
);
2412 for (i
= 0; i
< nr_pages
; i
++) {
2413 copied
= min_t(const size_t, cur_len
, PAGE_SIZE
);
2414 copied
= iov_iter_copy_from_user(wdata
->pages
[i
], &it
,
2417 iov_iter_advance(&it
, copied
);
2419 cur_len
= save_len
- cur_len
;
2421 wdata
->sync_mode
= WB_SYNC_ALL
;
2422 wdata
->nr_pages
= nr_pages
;
2423 wdata
->offset
= (__u64
)offset
;
2424 wdata
->cfile
= cifsFileInfo_get(open_file
);
2426 wdata
->bytes
= cur_len
;
2427 wdata
->pagesz
= PAGE_SIZE
;
2428 wdata
->tailsz
= cur_len
- ((nr_pages
- 1) * PAGE_SIZE
);
2429 rc
= cifs_uncached_retry_writev(wdata
);
2431 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2435 list_add_tail(&wdata
->list
, &wdata_list
);
2441 * If at least one write was successfully sent, then discard any rc
2442 * value from the later writes. If the other write succeeds, then
2443 * we'll end up returning whatever was written. If it fails, then
2444 * we'll get a new rc value from that.
2446 if (!list_empty(&wdata_list
))
2450 * Wait for and collect replies for any successful sends in order of
2451 * increasing offset. Once an error is hit or we get a fatal signal
2452 * while waiting, then return without waiting for any more replies.
2455 list_for_each_entry_safe(wdata
, tmp
, &wdata_list
, list
) {
2457 /* FIXME: freezable too? */
2458 rc
= wait_for_completion_killable(&wdata
->done
);
2461 else if (wdata
->result
)
2464 total_written
+= wdata
->bytes
;
2466 /* resend call if it's a retryable error */
2467 if (rc
== -EAGAIN
) {
2468 rc
= cifs_uncached_retry_writev(wdata
);
2472 list_del_init(&wdata
->list
);
2473 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2476 if (total_written
> 0)
2477 *poffset
+= total_written
;
2479 cifs_stats_bytes_written(tcon
, total_written
);
2480 return total_written
? total_written
: (ssize_t
)rc
;
2483 ssize_t
cifs_user_writev(struct kiocb
*iocb
, const struct iovec
*iov
,
2484 unsigned long nr_segs
, loff_t pos
)
2487 struct inode
*inode
;
2489 inode
= file_inode(iocb
->ki_filp
);
2492 * BB - optimize the way when signing is disabled. We can drop this
2493 * extra memory-to-memory copying and use iovec buffers for constructing
2497 written
= cifs_iovec_write(iocb
->ki_filp
, iov
, nr_segs
, &pos
);
2499 CIFS_I(inode
)->invalid_mapping
= true;
2507 cifs_writev(struct kiocb
*iocb
, const struct iovec
*iov
,
2508 unsigned long nr_segs
, loff_t pos
)
2510 struct file
*file
= iocb
->ki_filp
;
2511 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)file
->private_data
;
2512 struct inode
*inode
= file
->f_mapping
->host
;
2513 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
2514 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
2515 ssize_t rc
= -EACCES
;
2517 BUG_ON(iocb
->ki_pos
!= pos
);
2519 sb_start_write(inode
->i_sb
);
2522 * We need to hold the sem to be sure nobody modifies lock list
2523 * with a brlock that prevents writing.
2525 down_read(&cinode
->lock_sem
);
2526 if (!cifs_find_lock_conflict(cfile
, pos
, iov_length(iov
, nr_segs
),
2527 server
->vals
->exclusive_lock_type
, NULL
,
2529 mutex_lock(&inode
->i_mutex
);
2530 rc
= __generic_file_aio_write(iocb
, iov
, nr_segs
,
2532 mutex_unlock(&inode
->i_mutex
);
2535 if (rc
> 0 || rc
== -EIOCBQUEUED
) {
2538 err
= generic_write_sync(file
, pos
, rc
);
2539 if (err
< 0 && rc
> 0)
2543 up_read(&cinode
->lock_sem
);
2544 sb_end_write(inode
->i_sb
);
2549 cifs_strict_writev(struct kiocb
*iocb
, const struct iovec
*iov
,
2550 unsigned long nr_segs
, loff_t pos
)
2552 struct inode
*inode
= file_inode(iocb
->ki_filp
);
2553 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
2554 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2555 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)
2556 iocb
->ki_filp
->private_data
;
2557 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
2560 if (cinode
->clientCanCacheAll
) {
2561 if (cap_unix(tcon
->ses
) &&
2562 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
))
2563 && ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
2564 return generic_file_aio_write(iocb
, iov
, nr_segs
, pos
);
2565 return cifs_writev(iocb
, iov
, nr_segs
, pos
);
2568 * For non-oplocked files in strict cache mode we need to write the data
2569 * to the server exactly from the pos to pos+len-1 rather than flush all
2570 * affected pages because it may cause a error with mandatory locks on
2571 * these pages but not on the region from pos to ppos+len-1.
2573 written
= cifs_user_writev(iocb
, iov
, nr_segs
, pos
);
2574 if (written
> 0 && cinode
->clientCanCacheRead
) {
2576 * Windows 7 server can delay breaking level2 oplock if a write
2577 * request comes - break it on the client to prevent reading
2580 cifs_invalidate_mapping(inode
);
2581 cFYI(1, "Set no oplock for inode=%p after a write operation",
2583 cinode
->clientCanCacheRead
= false;
2588 static struct cifs_readdata
*
2589 cifs_readdata_alloc(unsigned int nr_pages
, work_func_t complete
)
2591 struct cifs_readdata
*rdata
;
2593 rdata
= kzalloc(sizeof(*rdata
) + (sizeof(struct page
*) * nr_pages
),
2595 if (rdata
!= NULL
) {
2596 kref_init(&rdata
->refcount
);
2597 INIT_LIST_HEAD(&rdata
->list
);
2598 init_completion(&rdata
->done
);
2599 INIT_WORK(&rdata
->work
, complete
);
2606 cifs_readdata_release(struct kref
*refcount
)
2608 struct cifs_readdata
*rdata
= container_of(refcount
,
2609 struct cifs_readdata
, refcount
);
2612 cifsFileInfo_put(rdata
->cfile
);
2618 cifs_read_allocate_pages(struct cifs_readdata
*rdata
, unsigned int nr_pages
)
2624 for (i
= 0; i
< nr_pages
; i
++) {
2625 page
= alloc_page(GFP_KERNEL
|__GFP_HIGHMEM
);
2630 rdata
->pages
[i
] = page
;
2634 for (i
= 0; i
< nr_pages
; i
++) {
2635 put_page(rdata
->pages
[i
]);
2636 rdata
->pages
[i
] = NULL
;
2643 cifs_uncached_readdata_release(struct kref
*refcount
)
2645 struct cifs_readdata
*rdata
= container_of(refcount
,
2646 struct cifs_readdata
, refcount
);
2649 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
2650 put_page(rdata
->pages
[i
]);
2651 rdata
->pages
[i
] = NULL
;
2653 cifs_readdata_release(refcount
);
2657 cifs_retry_async_readv(struct cifs_readdata
*rdata
)
2660 struct TCP_Server_Info
*server
;
2662 server
= tlink_tcon(rdata
->cfile
->tlink
)->ses
->server
;
2665 if (rdata
->cfile
->invalidHandle
) {
2666 rc
= cifs_reopen_file(rdata
->cfile
, true);
2670 rc
= server
->ops
->async_readv(rdata
);
2671 } while (rc
== -EAGAIN
);
2677 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2678 * @rdata: the readdata response with list of pages holding data
2679 * @iov: vector in which we should copy the data
2680 * @nr_segs: number of segments in vector
2681 * @offset: offset into file of the first iovec
2682 * @copied: used to return the amount of data copied to the iov
2684 * This function copies data from a list of pages in a readdata response into
2685 * an array of iovecs. It will first calculate where the data should go
2686 * based on the info in the readdata and then copy the data into that spot.
2689 cifs_readdata_to_iov(struct cifs_readdata
*rdata
, const struct iovec
*iov
,
2690 unsigned long nr_segs
, loff_t offset
, ssize_t
*copied
)
2694 size_t pos
= rdata
->offset
- offset
;
2695 ssize_t remaining
= rdata
->bytes
;
2696 unsigned char *pdata
;
2699 /* set up iov_iter and advance to the correct offset */
2700 iov_iter_init(&ii
, iov
, nr_segs
, iov_length(iov
, nr_segs
), 0);
2701 iov_iter_advance(&ii
, pos
);
2704 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
2706 struct page
*page
= rdata
->pages
[i
];
2708 /* copy a whole page or whatever's left */
2709 copy
= min_t(ssize_t
, remaining
, PAGE_SIZE
);
2711 /* ...but limit it to whatever space is left in the iov */
2712 copy
= min_t(ssize_t
, copy
, iov_iter_count(&ii
));
2714 /* go while there's data to be copied and no errors */
2717 rc
= memcpy_toiovecend(ii
.iov
, pdata
, ii
.iov_offset
,
2723 iov_iter_advance(&ii
, copy
);
2732 cifs_uncached_readv_complete(struct work_struct
*work
)
2734 struct cifs_readdata
*rdata
= container_of(work
,
2735 struct cifs_readdata
, work
);
2737 complete(&rdata
->done
);
2738 kref_put(&rdata
->refcount
, cifs_uncached_readdata_release
);
2742 cifs_uncached_read_into_pages(struct TCP_Server_Info
*server
,
2743 struct cifs_readdata
*rdata
, unsigned int len
)
2745 int total_read
= 0, result
= 0;
2747 unsigned int nr_pages
= rdata
->nr_pages
;
2750 rdata
->tailsz
= PAGE_SIZE
;
2751 for (i
= 0; i
< nr_pages
; i
++) {
2752 struct page
*page
= rdata
->pages
[i
];
2754 if (len
>= PAGE_SIZE
) {
2755 /* enough data to fill the page */
2756 iov
.iov_base
= kmap(page
);
2757 iov
.iov_len
= PAGE_SIZE
;
2758 cFYI(1, "%u: iov_base=%p iov_len=%zu",
2759 i
, iov
.iov_base
, iov
.iov_len
);
2761 } else if (len
> 0) {
2762 /* enough for partial page, fill and zero the rest */
2763 iov
.iov_base
= kmap(page
);
2765 cFYI(1, "%u: iov_base=%p iov_len=%zu",
2766 i
, iov
.iov_base
, iov
.iov_len
);
2767 memset(iov
.iov_base
+ len
, '\0', PAGE_SIZE
- len
);
2768 rdata
->tailsz
= len
;
2771 /* no need to hold page hostage */
2772 rdata
->pages
[i
] = NULL
;
2778 result
= cifs_readv_from_socket(server
, &iov
, 1, iov
.iov_len
);
2783 total_read
+= result
;
2786 return total_read
> 0 ? total_read
: result
;
2790 cifs_iovec_read(struct file
*file
, const struct iovec
*iov
,
2791 unsigned long nr_segs
, loff_t
*poffset
)
2794 size_t len
, cur_len
;
2795 ssize_t total_read
= 0;
2796 loff_t offset
= *poffset
;
2797 unsigned int npages
;
2798 struct cifs_sb_info
*cifs_sb
;
2799 struct cifs_tcon
*tcon
;
2800 struct cifsFileInfo
*open_file
;
2801 struct cifs_readdata
*rdata
, *tmp
;
2802 struct list_head rdata_list
;
2808 len
= iov_length(iov
, nr_segs
);
2812 INIT_LIST_HEAD(&rdata_list
);
2813 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
2814 open_file
= file
->private_data
;
2815 tcon
= tlink_tcon(open_file
->tlink
);
2817 if (!tcon
->ses
->server
->ops
->async_readv
)
2820 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
2821 pid
= open_file
->pid
;
2823 pid
= current
->tgid
;
2825 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
2826 cFYI(1, "attempting read on write only file instance");
2829 cur_len
= min_t(const size_t, len
- total_read
, cifs_sb
->rsize
);
2830 npages
= DIV_ROUND_UP(cur_len
, PAGE_SIZE
);
2832 /* allocate a readdata struct */
2833 rdata
= cifs_readdata_alloc(npages
,
2834 cifs_uncached_readv_complete
);
2840 rc
= cifs_read_allocate_pages(rdata
, npages
);
2844 rdata
->cfile
= cifsFileInfo_get(open_file
);
2845 rdata
->nr_pages
= npages
;
2846 rdata
->offset
= offset
;
2847 rdata
->bytes
= cur_len
;
2849 rdata
->pagesz
= PAGE_SIZE
;
2850 rdata
->read_into_pages
= cifs_uncached_read_into_pages
;
2852 rc
= cifs_retry_async_readv(rdata
);
2855 kref_put(&rdata
->refcount
,
2856 cifs_uncached_readdata_release
);
2860 list_add_tail(&rdata
->list
, &rdata_list
);
2865 /* if at least one read request send succeeded, then reset rc */
2866 if (!list_empty(&rdata_list
))
2869 /* the loop below should proceed in the order of increasing offsets */
2871 list_for_each_entry_safe(rdata
, tmp
, &rdata_list
, list
) {
2875 /* FIXME: freezable sleep too? */
2876 rc
= wait_for_completion_killable(&rdata
->done
);
2879 else if (rdata
->result
)
2882 rc
= cifs_readdata_to_iov(rdata
, iov
,
2885 total_read
+= copied
;
2888 /* resend call if it's a retryable error */
2889 if (rc
== -EAGAIN
) {
2890 rc
= cifs_retry_async_readv(rdata
);
2894 list_del_init(&rdata
->list
);
2895 kref_put(&rdata
->refcount
, cifs_uncached_readdata_release
);
2898 cifs_stats_bytes_read(tcon
, total_read
);
2899 *poffset
+= total_read
;
2901 /* mask nodata case */
2905 return total_read
? total_read
: rc
;
2908 ssize_t
cifs_user_readv(struct kiocb
*iocb
, const struct iovec
*iov
,
2909 unsigned long nr_segs
, loff_t pos
)
2913 read
= cifs_iovec_read(iocb
->ki_filp
, iov
, nr_segs
, &pos
);
2921 cifs_strict_readv(struct kiocb
*iocb
, const struct iovec
*iov
,
2922 unsigned long nr_segs
, loff_t pos
)
2924 struct inode
*inode
= file_inode(iocb
->ki_filp
);
2925 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
2926 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2927 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)
2928 iocb
->ki_filp
->private_data
;
2929 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
2933 * In strict cache mode we need to read from the server all the time
2934 * if we don't have level II oplock because the server can delay mtime
2935 * change - so we can't make a decision about inode invalidating.
2936 * And we can also fail with pagereading if there are mandatory locks
2937 * on pages affected by this read but not on the region from pos to
2940 if (!cinode
->clientCanCacheRead
)
2941 return cifs_user_readv(iocb
, iov
, nr_segs
, pos
);
2943 if (cap_unix(tcon
->ses
) &&
2944 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
2945 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
2946 return generic_file_aio_read(iocb
, iov
, nr_segs
, pos
);
2949 * We need to hold the sem to be sure nobody modifies lock list
2950 * with a brlock that prevents reading.
2952 down_read(&cinode
->lock_sem
);
2953 if (!cifs_find_lock_conflict(cfile
, pos
, iov_length(iov
, nr_segs
),
2954 tcon
->ses
->server
->vals
->shared_lock_type
,
2955 NULL
, CIFS_READ_OP
))
2956 rc
= generic_file_aio_read(iocb
, iov
, nr_segs
, pos
);
2957 up_read(&cinode
->lock_sem
);
2962 cifs_read(struct file
*file
, char *read_data
, size_t read_size
, loff_t
*offset
)
2965 unsigned int bytes_read
= 0;
2966 unsigned int total_read
;
2967 unsigned int current_read_size
;
2969 struct cifs_sb_info
*cifs_sb
;
2970 struct cifs_tcon
*tcon
;
2971 struct TCP_Server_Info
*server
;
2974 struct cifsFileInfo
*open_file
;
2975 struct cifs_io_parms io_parms
;
2976 int buf_type
= CIFS_NO_BUFFER
;
2980 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
2982 /* FIXME: set up handlers for larger reads and/or convert to async */
2983 rsize
= min_t(unsigned int, cifs_sb
->rsize
, CIFSMaxBufSize
);
2985 if (file
->private_data
== NULL
) {
2990 open_file
= file
->private_data
;
2991 tcon
= tlink_tcon(open_file
->tlink
);
2992 server
= tcon
->ses
->server
;
2994 if (!server
->ops
->sync_read
) {
2999 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
3000 pid
= open_file
->pid
;
3002 pid
= current
->tgid
;
3004 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
3005 cFYI(1, "attempting read on write only file instance");
3007 for (total_read
= 0, cur_offset
= read_data
; read_size
> total_read
;
3008 total_read
+= bytes_read
, cur_offset
+= bytes_read
) {
3009 current_read_size
= min_t(uint
, read_size
- total_read
, rsize
);
3011 * For windows me and 9x we do not want to request more than it
3012 * negotiated since it will refuse the read then.
3014 if ((tcon
->ses
) && !(tcon
->ses
->capabilities
&
3015 tcon
->ses
->server
->vals
->cap_large_files
)) {
3016 current_read_size
= min_t(uint
, current_read_size
,
3020 while (rc
== -EAGAIN
) {
3021 if (open_file
->invalidHandle
) {
3022 rc
= cifs_reopen_file(open_file
, true);
3027 io_parms
.tcon
= tcon
;
3028 io_parms
.offset
= *offset
;
3029 io_parms
.length
= current_read_size
;
3030 rc
= server
->ops
->sync_read(xid
, open_file
, &io_parms
,
3031 &bytes_read
, &cur_offset
,
3034 if (rc
|| (bytes_read
== 0)) {
3042 cifs_stats_bytes_read(tcon
, total_read
);
3043 *offset
+= bytes_read
;
3051 * If the page is mmap'ed into a process' page tables, then we need to make
3052 * sure that it doesn't change while being written back.
3055 cifs_page_mkwrite(struct vm_area_struct
*vma
, struct vm_fault
*vmf
)
3057 struct page
*page
= vmf
->page
;
3060 return VM_FAULT_LOCKED
;
3063 static struct vm_operations_struct cifs_file_vm_ops
= {
3064 .fault
= filemap_fault
,
3065 .page_mkwrite
= cifs_page_mkwrite
,
3066 .remap_pages
= generic_file_remap_pages
,
3069 int cifs_file_strict_mmap(struct file
*file
, struct vm_area_struct
*vma
)
3072 struct inode
*inode
= file_inode(file
);
3076 if (!CIFS_I(inode
)->clientCanCacheRead
) {
3077 rc
= cifs_invalidate_mapping(inode
);
3082 rc
= generic_file_mmap(file
, vma
);
3084 vma
->vm_ops
= &cifs_file_vm_ops
;
3089 int cifs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
3094 rc
= cifs_revalidate_file(file
);
3096 cFYI(1, "Validation prior to mmap failed, error=%d", rc
);
3100 rc
= generic_file_mmap(file
, vma
);
3102 vma
->vm_ops
= &cifs_file_vm_ops
;
3108 cifs_readv_complete(struct work_struct
*work
)
3111 struct cifs_readdata
*rdata
= container_of(work
,
3112 struct cifs_readdata
, work
);
3114 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
3115 struct page
*page
= rdata
->pages
[i
];
3117 lru_cache_add_file(page
);
3119 if (rdata
->result
== 0) {
3120 flush_dcache_page(page
);
3121 SetPageUptodate(page
);
3126 if (rdata
->result
== 0)
3127 cifs_readpage_to_fscache(rdata
->mapping
->host
, page
);
3129 page_cache_release(page
);
3130 rdata
->pages
[i
] = NULL
;
3132 kref_put(&rdata
->refcount
, cifs_readdata_release
);
3136 cifs_readpages_read_into_pages(struct TCP_Server_Info
*server
,
3137 struct cifs_readdata
*rdata
, unsigned int len
)
3139 int total_read
= 0, result
= 0;
3143 unsigned int nr_pages
= rdata
->nr_pages
;
3146 /* determine the eof that the server (probably) has */
3147 eof
= CIFS_I(rdata
->mapping
->host
)->server_eof
;
3148 eof_index
= eof
? (eof
- 1) >> PAGE_CACHE_SHIFT
: 0;
3149 cFYI(1, "eof=%llu eof_index=%lu", eof
, eof_index
);
3151 rdata
->tailsz
= PAGE_CACHE_SIZE
;
3152 for (i
= 0; i
< nr_pages
; i
++) {
3153 struct page
*page
= rdata
->pages
[i
];
3155 if (len
>= PAGE_CACHE_SIZE
) {
3156 /* enough data to fill the page */
3157 iov
.iov_base
= kmap(page
);
3158 iov
.iov_len
= PAGE_CACHE_SIZE
;
3159 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
3160 i
, page
->index
, iov
.iov_base
, iov
.iov_len
);
3161 len
-= PAGE_CACHE_SIZE
;
3162 } else if (len
> 0) {
3163 /* enough for partial page, fill and zero the rest */
3164 iov
.iov_base
= kmap(page
);
3166 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
3167 i
, page
->index
, iov
.iov_base
, iov
.iov_len
);
3168 memset(iov
.iov_base
+ len
,
3169 '\0', PAGE_CACHE_SIZE
- len
);
3170 rdata
->tailsz
= len
;
3172 } else if (page
->index
> eof_index
) {
3174 * The VFS will not try to do readahead past the
3175 * i_size, but it's possible that we have outstanding
3176 * writes with gaps in the middle and the i_size hasn't
3177 * caught up yet. Populate those with zeroed out pages
3178 * to prevent the VFS from repeatedly attempting to
3179 * fill them until the writes are flushed.
3181 zero_user(page
, 0, PAGE_CACHE_SIZE
);
3182 lru_cache_add_file(page
);
3183 flush_dcache_page(page
);
3184 SetPageUptodate(page
);
3186 page_cache_release(page
);
3187 rdata
->pages
[i
] = NULL
;
3191 /* no need to hold page hostage */
3192 lru_cache_add_file(page
);
3194 page_cache_release(page
);
3195 rdata
->pages
[i
] = NULL
;
3200 result
= cifs_readv_from_socket(server
, &iov
, 1, iov
.iov_len
);
3205 total_read
+= result
;
3208 return total_read
> 0 ? total_read
: result
;
3211 static int cifs_readpages(struct file
*file
, struct address_space
*mapping
,
3212 struct list_head
*page_list
, unsigned num_pages
)
3215 struct list_head tmplist
;
3216 struct cifsFileInfo
*open_file
= file
->private_data
;
3217 struct cifs_sb_info
*cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
3218 unsigned int rsize
= cifs_sb
->rsize
;
3222 * Give up immediately if rsize is too small to read an entire page.
3223 * The VFS will fall back to readpage. We should never reach this
3224 * point however since we set ra_pages to 0 when the rsize is smaller
3225 * than a cache page.
3227 if (unlikely(rsize
< PAGE_CACHE_SIZE
))
3231 * Reads as many pages as possible from fscache. Returns -ENOBUFS
3232 * immediately if the cookie is negative
3234 rc
= cifs_readpages_from_fscache(mapping
->host
, mapping
, page_list
,
3239 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
3240 pid
= open_file
->pid
;
3242 pid
= current
->tgid
;
3245 INIT_LIST_HEAD(&tmplist
);
3247 cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__
, file
,
3248 mapping
, num_pages
);
3251 * Start with the page at end of list and move it to private
3252 * list. Do the same with any following pages until we hit
3253 * the rsize limit, hit an index discontinuity, or run out of
3254 * pages. Issue the async read and then start the loop again
3255 * until the list is empty.
3257 * Note that list order is important. The page_list is in
3258 * the order of declining indexes. When we put the pages in
3259 * the rdata->pages, then we want them in increasing order.
3261 while (!list_empty(page_list
)) {
3263 unsigned int bytes
= PAGE_CACHE_SIZE
;
3264 unsigned int expected_index
;
3265 unsigned int nr_pages
= 1;
3267 struct page
*page
, *tpage
;
3268 struct cifs_readdata
*rdata
;
3270 page
= list_entry(page_list
->prev
, struct page
, lru
);
3273 * Lock the page and put it in the cache. Since no one else
3274 * should have access to this page, we're safe to simply set
3275 * PG_locked without checking it first.
3277 __set_page_locked(page
);
3278 rc
= add_to_page_cache_locked(page
, mapping
,
3279 page
->index
, GFP_KERNEL
);
3281 /* give up if we can't stick it in the cache */
3283 __clear_page_locked(page
);
3287 /* move first page to the tmplist */
3288 offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
3289 list_move_tail(&page
->lru
, &tmplist
);
3291 /* now try and add more pages onto the request */
3292 expected_index
= page
->index
+ 1;
3293 list_for_each_entry_safe_reverse(page
, tpage
, page_list
, lru
) {
3294 /* discontinuity ? */
3295 if (page
->index
!= expected_index
)
3298 /* would this page push the read over the rsize? */
3299 if (bytes
+ PAGE_CACHE_SIZE
> rsize
)
3302 __set_page_locked(page
);
3303 if (add_to_page_cache_locked(page
, mapping
,
3304 page
->index
, GFP_KERNEL
)) {
3305 __clear_page_locked(page
);
3308 list_move_tail(&page
->lru
, &tmplist
);
3309 bytes
+= PAGE_CACHE_SIZE
;
3314 rdata
= cifs_readdata_alloc(nr_pages
, cifs_readv_complete
);
3316 /* best to give up if we're out of mem */
3317 list_for_each_entry_safe(page
, tpage
, &tmplist
, lru
) {
3318 list_del(&page
->lru
);
3319 lru_cache_add_file(page
);
3321 page_cache_release(page
);
3327 rdata
->cfile
= cifsFileInfo_get(open_file
);
3328 rdata
->mapping
= mapping
;
3329 rdata
->offset
= offset
;
3330 rdata
->bytes
= bytes
;
3332 rdata
->pagesz
= PAGE_CACHE_SIZE
;
3333 rdata
->read_into_pages
= cifs_readpages_read_into_pages
;
3335 list_for_each_entry_safe(page
, tpage
, &tmplist
, lru
) {
3336 list_del(&page
->lru
);
3337 rdata
->pages
[rdata
->nr_pages
++] = page
;
3340 rc
= cifs_retry_async_readv(rdata
);
3342 for (i
= 0; i
< rdata
->nr_pages
; i
++) {
3343 page
= rdata
->pages
[i
];
3344 lru_cache_add_file(page
);
3346 page_cache_release(page
);
3348 kref_put(&rdata
->refcount
, cifs_readdata_release
);
3352 kref_put(&rdata
->refcount
, cifs_readdata_release
);
3358 static int cifs_readpage_worker(struct file
*file
, struct page
*page
,
3364 /* Is the page cached? */
3365 rc
= cifs_readpage_from_fscache(file_inode(file
), page
);
3369 page_cache_get(page
);
3370 read_data
= kmap(page
);
3371 /* for reads over a certain size could initiate async read ahead */
3373 rc
= cifs_read(file
, read_data
, PAGE_CACHE_SIZE
, poffset
);
3378 cFYI(1, "Bytes read %d", rc
);
3380 file_inode(file
)->i_atime
=
3381 current_fs_time(file_inode(file
)->i_sb
);
3383 if (PAGE_CACHE_SIZE
> rc
)
3384 memset(read_data
+ rc
, 0, PAGE_CACHE_SIZE
- rc
);
3386 flush_dcache_page(page
);
3387 SetPageUptodate(page
);
3389 /* send this page to the cache */
3390 cifs_readpage_to_fscache(file_inode(file
), page
);
3396 page_cache_release(page
);
3402 static int cifs_readpage(struct file
*file
, struct page
*page
)
3404 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
3410 if (file
->private_data
== NULL
) {
3416 cFYI(1, "readpage %p at offset %d 0x%x",
3417 page
, (int)offset
, (int)offset
);
3419 rc
= cifs_readpage_worker(file
, page
, &offset
);
3427 static int is_inode_writable(struct cifsInodeInfo
*cifs_inode
)
3429 struct cifsFileInfo
*open_file
;
3431 spin_lock(&cifs_file_list_lock
);
3432 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
3433 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_WRITE
) {
3434 spin_unlock(&cifs_file_list_lock
);
3438 spin_unlock(&cifs_file_list_lock
);
3442 /* We do not want to update the file size from server for inodes
3443 open for write - to avoid races with writepage extending
3444 the file - in the future we could consider allowing
3445 refreshing the inode only on increases in the file size
3446 but this is tricky to do without racing with writebehind
3447 page caching in the current Linux kernel design */
3448 bool is_size_safe_to_change(struct cifsInodeInfo
*cifsInode
, __u64 end_of_file
)
3453 if (is_inode_writable(cifsInode
)) {
3454 /* This inode is open for write at least once */
3455 struct cifs_sb_info
*cifs_sb
;
3457 cifs_sb
= CIFS_SB(cifsInode
->vfs_inode
.i_sb
);
3458 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
3459 /* since no page cache to corrupt on directio
3460 we can change size safely */
3464 if (i_size_read(&cifsInode
->vfs_inode
) < end_of_file
)
3472 static int cifs_write_begin(struct file
*file
, struct address_space
*mapping
,
3473 loff_t pos
, unsigned len
, unsigned flags
,
3474 struct page
**pagep
, void **fsdata
)
3476 pgoff_t index
= pos
>> PAGE_CACHE_SHIFT
;
3477 loff_t offset
= pos
& (PAGE_CACHE_SIZE
- 1);
3478 loff_t page_start
= pos
& PAGE_MASK
;
3483 cFYI(1, "write_begin from %lld len %d", (long long)pos
, len
);
3485 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
3491 if (PageUptodate(page
))
3495 * If we write a full page it will be up to date, no need to read from
3496 * the server. If the write is short, we'll end up doing a sync write
3499 if (len
== PAGE_CACHE_SIZE
)
3503 * optimize away the read when we have an oplock, and we're not
3504 * expecting to use any of the data we'd be reading in. That
3505 * is, when the page lies beyond the EOF, or straddles the EOF
3506 * and the write will cover all of the existing data.
3508 if (CIFS_I(mapping
->host
)->clientCanCacheRead
) {
3509 i_size
= i_size_read(mapping
->host
);
3510 if (page_start
>= i_size
||
3511 (offset
== 0 && (pos
+ len
) >= i_size
)) {
3512 zero_user_segments(page
, 0, offset
,
3516 * PageChecked means that the parts of the page
3517 * to which we're not writing are considered up
3518 * to date. Once the data is copied to the
3519 * page, it can be set uptodate.
3521 SetPageChecked(page
);
3526 if ((file
->f_flags
& O_ACCMODE
) != O_WRONLY
) {
3528 * might as well read a page, it is fast enough. If we get
3529 * an error, we don't need to return it. cifs_write_end will
3530 * do a sync write instead since PG_uptodate isn't set.
3532 cifs_readpage_worker(file
, page
, &page_start
);
3534 /* we could try using another file handle if there is one -
3535 but how would we lock it to prevent close of that handle
3536 racing with this read? In any case
3537 this will be written out by write_end so is fine */
3544 static int cifs_release_page(struct page
*page
, gfp_t gfp
)
3546 if (PagePrivate(page
))
3549 return cifs_fscache_release_page(page
, gfp
);
3552 static void cifs_invalidate_page(struct page
*page
, unsigned long offset
)
3554 struct cifsInodeInfo
*cifsi
= CIFS_I(page
->mapping
->host
);
3557 cifs_fscache_invalidate_page(page
, &cifsi
->vfs_inode
);
3560 static int cifs_launder_page(struct page
*page
)
3563 loff_t range_start
= page_offset(page
);
3564 loff_t range_end
= range_start
+ (loff_t
)(PAGE_CACHE_SIZE
- 1);
3565 struct writeback_control wbc
= {
3566 .sync_mode
= WB_SYNC_ALL
,
3568 .range_start
= range_start
,
3569 .range_end
= range_end
,
3572 cFYI(1, "Launder page: %p", page
);
3574 if (clear_page_dirty_for_io(page
))
3575 rc
= cifs_writepage_locked(page
, &wbc
);
3577 cifs_fscache_invalidate_page(page
, page
->mapping
->host
);
3581 void cifs_oplock_break(struct work_struct
*work
)
3583 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
3585 struct inode
*inode
= cfile
->dentry
->d_inode
;
3586 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
3587 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
3590 if (!cinode
->clientCanCacheAll
&& cinode
->clientCanCacheRead
&&
3591 cifs_has_mand_locks(cinode
)) {
3592 cFYI(1, "Reset oplock to None for inode=%p due to mand locks",
3594 cinode
->clientCanCacheRead
= false;
3597 if (inode
&& S_ISREG(inode
->i_mode
)) {
3598 if (cinode
->clientCanCacheRead
)
3599 break_lease(inode
, O_RDONLY
);
3601 break_lease(inode
, O_WRONLY
);
3602 rc
= filemap_fdatawrite(inode
->i_mapping
);
3603 if (cinode
->clientCanCacheRead
== 0) {
3604 rc
= filemap_fdatawait(inode
->i_mapping
);
3605 mapping_set_error(inode
->i_mapping
, rc
);
3606 cifs_invalidate_mapping(inode
);
3608 cFYI(1, "Oplock flush inode %p rc %d", inode
, rc
);
3611 rc
= cifs_push_locks(cfile
);
3613 cERROR(1, "Push locks rc = %d", rc
);
3616 * releasing stale oplock after recent reconnect of smb session using
3617 * a now incorrect file handle is not a data integrity issue but do
3618 * not bother sending an oplock release if session to server still is
3619 * disconnected since oplock already released by the server
3621 if (!cfile
->oplock_break_cancelled
) {
3622 rc
= tcon
->ses
->server
->ops
->oplock_response(tcon
, &cfile
->fid
,
3624 cFYI(1, "Oplock release rc = %d", rc
);
3628 const struct address_space_operations cifs_addr_ops
= {
3629 .readpage
= cifs_readpage
,
3630 .readpages
= cifs_readpages
,
3631 .writepage
= cifs_writepage
,
3632 .writepages
= cifs_writepages
,
3633 .write_begin
= cifs_write_begin
,
3634 .write_end
= cifs_write_end
,
3635 .set_page_dirty
= __set_page_dirty_nobuffers
,
3636 .releasepage
= cifs_release_page
,
3637 .invalidatepage
= cifs_invalidate_page
,
3638 .launder_page
= cifs_launder_page
,
3642 * cifs_readpages requires the server to support a buffer large enough to
3643 * contain the header plus one complete page of data. Otherwise, we need
3644 * to leave cifs_readpages out of the address space operations.
3646 const struct address_space_operations cifs_addr_ops_smallbuf
= {
3647 .readpage
= cifs_readpage
,
3648 .writepage
= cifs_writepage
,
3649 .writepages
= cifs_writepages
,
3650 .write_begin
= cifs_write_begin
,
3651 .write_end
= cifs_write_end
,
3652 .set_page_dirty
= __set_page_dirty_nobuffers
,
3653 .releasepage
= cifs_release_page
,
3654 .invalidatepage
= cifs_invalidate_page
,
3655 .launder_page
= cifs_launder_page
,