4 * Copyright (C) International Business Machines Corp., 2002, 2011
5 * Author(s): Steve French (sfrench@us.ibm.com),
6 * Pavel Shilovsky ((pshilovsky@samba.org) 2012
8 * This library is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published
10 * by the Free Software Foundation; either version 2.1 of the License, or
11 * (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
16 * the GNU Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/stat.h>
24 #include <linux/slab.h>
25 #include <linux/pagemap.h>
26 #include <asm/div64.h>
30 #include "cifsproto.h"
31 #include "cifs_debug.h"
32 #include "cifs_fs_sb.h"
33 #include "cifs_unicode.h"
35 #include "smb2proto.h"
38 smb2_set_oplock_level(struct cifsInodeInfo
*cinode
, __u32 oplock
)
41 if (oplock
== SMB2_OPLOCK_LEVEL_NOCHANGE
)
43 if (oplock
== SMB2_OPLOCK_LEVEL_EXCLUSIVE
||
44 oplock
== SMB2_OPLOCK_LEVEL_BATCH
) {
45 cinode
->clientCanCacheAll
= true;
46 cinode
->clientCanCacheRead
= true;
47 cifs_dbg(FYI
, "Exclusive Oplock granted on inode %p\n",
49 } else if (oplock
== SMB2_OPLOCK_LEVEL_II
) {
50 cinode
->clientCanCacheAll
= false;
51 cinode
->clientCanCacheRead
= true;
52 cifs_dbg(FYI
, "Level II Oplock granted on inode %p\n",
55 cinode
->clientCanCacheAll
= false;
56 cinode
->clientCanCacheRead
= false;
61 smb2_open_file(const unsigned int xid
, struct cifs_open_parms
*oparms
,
62 __u32
*oplock
, FILE_ALL_INFO
*buf
)
66 struct smb2_file_all_info
*smb2_data
= NULL
;
68 struct cifs_fid
*fid
= oparms
->fid
;
70 smb2_path
= cifs_convert_path_to_utf16(oparms
->path
, oparms
->cifs_sb
);
71 if (smb2_path
== NULL
) {
76 smb2_data
= kzalloc(sizeof(struct smb2_file_all_info
) + MAX_NAME
* 2,
78 if (smb2_data
== NULL
) {
83 oparms
->desired_access
|= FILE_READ_ATTRIBUTES
;
84 *smb2_oplock
= SMB2_OPLOCK_LEVEL_BATCH
;
86 if (oparms
->tcon
->ses
->server
->capabilities
& SMB2_GLOBAL_CAP_LEASING
)
87 memcpy(smb2_oplock
+ 1, fid
->lease_key
, SMB2_LEASE_KEY_SIZE
);
89 rc
= SMB2_open(xid
, oparms
, smb2_path
, smb2_oplock
, smb2_data
);
94 /* open response does not have IndexNumber field - get it */
95 rc
= SMB2_get_srv_num(xid
, oparms
->tcon
, fid
->persistent_fid
,
97 &smb2_data
->IndexNumber
);
99 /* let get_inode_info disable server inode numbers */
100 smb2_data
->IndexNumber
= 0;
103 move_smb2_info_to_cifs(buf
, smb2_data
);
106 *oplock
= *smb2_oplock
;
114 smb2_unlock_range(struct cifsFileInfo
*cfile
, struct file_lock
*flock
,
115 const unsigned int xid
)
117 int rc
= 0, stored_rc
;
118 unsigned int max_num
, num
= 0, max_buf
;
119 struct smb2_lock_element
*buf
, *cur
;
120 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
121 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
122 struct cifsLockInfo
*li
, *tmp
;
123 __u64 length
= 1 + flock
->fl_end
- flock
->fl_start
;
124 struct list_head tmp_llist
;
126 INIT_LIST_HEAD(&tmp_llist
);
129 * Accessing maxBuf is racy with cifs_reconnect - need to store value
130 * and check it for zero before using.
132 max_buf
= tcon
->ses
->server
->maxBuf
;
136 max_num
= max_buf
/ sizeof(struct smb2_lock_element
);
137 buf
= kzalloc(max_num
* sizeof(struct smb2_lock_element
), GFP_KERNEL
);
143 down_write(&cinode
->lock_sem
);
144 list_for_each_entry_safe(li
, tmp
, &cfile
->llist
->locks
, llist
) {
145 if (flock
->fl_start
> li
->offset
||
146 (flock
->fl_start
+ length
) <
147 (li
->offset
+ li
->length
))
149 if (current
->tgid
!= li
->pid
)
151 if (cinode
->can_cache_brlcks
) {
153 * We can cache brlock requests - simply remove a lock
154 * from the file's list.
156 list_del(&li
->llist
);
157 cifs_del_lock_waiters(li
);
161 cur
->Length
= cpu_to_le64(li
->length
);
162 cur
->Offset
= cpu_to_le64(li
->offset
);
163 cur
->Flags
= cpu_to_le32(SMB2_LOCKFLAG_UNLOCK
);
165 * We need to save a lock here to let us add it again to the
166 * file's list if the unlock range request fails on the server.
168 list_move(&li
->llist
, &tmp_llist
);
169 if (++num
== max_num
) {
170 stored_rc
= smb2_lockv(xid
, tcon
,
171 cfile
->fid
.persistent_fid
,
172 cfile
->fid
.volatile_fid
,
173 current
->tgid
, num
, buf
);
176 * We failed on the unlock range request - add
177 * all locks from the tmp list to the head of
180 cifs_move_llist(&tmp_llist
,
181 &cfile
->llist
->locks
);
185 * The unlock range request succeed - free the
188 cifs_free_llist(&tmp_llist
);
195 stored_rc
= smb2_lockv(xid
, tcon
, cfile
->fid
.persistent_fid
,
196 cfile
->fid
.volatile_fid
, current
->tgid
,
199 cifs_move_llist(&tmp_llist
, &cfile
->llist
->locks
);
202 cifs_free_llist(&tmp_llist
);
204 up_write(&cinode
->lock_sem
);
211 smb2_push_mand_fdlocks(struct cifs_fid_locks
*fdlocks
, const unsigned int xid
,
212 struct smb2_lock_element
*buf
, unsigned int max_num
)
214 int rc
= 0, stored_rc
;
215 struct cifsFileInfo
*cfile
= fdlocks
->cfile
;
216 struct cifsLockInfo
*li
;
217 unsigned int num
= 0;
218 struct smb2_lock_element
*cur
= buf
;
219 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
221 list_for_each_entry(li
, &fdlocks
->locks
, llist
) {
222 cur
->Length
= cpu_to_le64(li
->length
);
223 cur
->Offset
= cpu_to_le64(li
->offset
);
224 cur
->Flags
= cpu_to_le32(li
->type
|
225 SMB2_LOCKFLAG_FAIL_IMMEDIATELY
);
226 if (++num
== max_num
) {
227 stored_rc
= smb2_lockv(xid
, tcon
,
228 cfile
->fid
.persistent_fid
,
229 cfile
->fid
.volatile_fid
,
230 current
->tgid
, num
, buf
);
239 stored_rc
= smb2_lockv(xid
, tcon
,
240 cfile
->fid
.persistent_fid
,
241 cfile
->fid
.volatile_fid
,
242 current
->tgid
, num
, buf
);
251 smb2_push_mandatory_locks(struct cifsFileInfo
*cfile
)
253 int rc
= 0, stored_rc
;
255 unsigned int max_num
, max_buf
;
256 struct smb2_lock_element
*buf
;
257 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
258 struct cifs_fid_locks
*fdlocks
;
263 * Accessing maxBuf is racy with cifs_reconnect - need to store value
264 * and check it for zero before using.
266 max_buf
= tlink_tcon(cfile
->tlink
)->ses
->server
->maxBuf
;
272 max_num
= max_buf
/ sizeof(struct smb2_lock_element
);
273 buf
= kzalloc(max_num
* sizeof(struct smb2_lock_element
), GFP_KERNEL
);
279 list_for_each_entry(fdlocks
, &cinode
->llist
, llist
) {
280 stored_rc
= smb2_push_mand_fdlocks(fdlocks
, xid
, buf
, max_num
);