blob: 04a81a4142c3235f1bb1693b9be4c73580023c2b [file] [log] [blame]
Pavel Shilovskyf0df7372012-09-18 16:20:26 -07001/*
2 * fs/cifs/smb2file.c
3 *
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
7 *
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.
12 *
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.
17 *
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
21 */
22#include <linux/fs.h>
23#include <linux/stat.h>
24#include <linux/slab.h>
25#include <linux/pagemap.h>
26#include <asm/div64.h>
27#include "cifsfs.h"
28#include "cifspdu.h"
29#include "cifsglob.h"
30#include "cifsproto.h"
31#include "cifs_debug.h"
32#include "cifs_fs_sb.h"
33#include "cifs_unicode.h"
34#include "fscache.h"
35#include "smb2proto.h"
36
Pavel Shilovsky2e44b282012-09-18 16:20:33 -070037void
38smb2_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock)
39{
40 oplock &= 0xFF;
Pavel Shilovsky0822f512012-09-19 06:22:45 -070041 if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE)
42 return;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +040043 if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE ||
44 oplock == SMB2_OPLOCK_LEVEL_BATCH) {
Pavel Shilovsky2e44b282012-09-18 16:20:33 -070045 cinode->clientCanCacheAll = true;
46 cinode->clientCanCacheRead = true;
Joe Perchesf96637b2013-05-04 22:12:25 -050047 cifs_dbg(FYI, "Exclusive Oplock granted on inode %p\n",
48 &cinode->vfs_inode);
Pavel Shilovsky2e44b282012-09-18 16:20:33 -070049 } else if (oplock == SMB2_OPLOCK_LEVEL_II) {
50 cinode->clientCanCacheAll = false;
51 cinode->clientCanCacheRead = true;
Joe Perchesf96637b2013-05-04 22:12:25 -050052 cifs_dbg(FYI, "Level II Oplock granted on inode %p\n",
53 &cinode->vfs_inode);
Pavel Shilovsky2e44b282012-09-18 16:20:33 -070054 } else {
55 cinode->clientCanCacheAll = false;
56 cinode->clientCanCacheRead = false;
57 }
58}
59
Pavel Shilovskyf0df7372012-09-18 16:20:26 -070060int
Pavel Shilovsky226730b2013-07-05 12:00:30 +040061smb2_open_file(const unsigned int xid, struct cifs_open_parms *oparms,
62 __u32 *oplock, FILE_ALL_INFO *buf)
Pavel Shilovskyf0df7372012-09-18 16:20:26 -070063{
64 int rc;
65 __le16 *smb2_path;
66 struct smb2_file_all_info *smb2_data = NULL;
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -070067 __u8 smb2_oplock[17];
Pavel Shilovsky226730b2013-07-05 12:00:30 +040068 struct cifs_fid *fid = oparms->fid;
Pavel Shilovskyf0df7372012-09-18 16:20:26 -070069
Pavel Shilovsky226730b2013-07-05 12:00:30 +040070 smb2_path = cifs_convert_path_to_utf16(oparms->path, oparms->cifs_sb);
Pavel Shilovskyf0df7372012-09-18 16:20:26 -070071 if (smb2_path == NULL) {
72 rc = -ENOMEM;
73 goto out;
74 }
75
76 smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + MAX_NAME * 2,
77 GFP_KERNEL);
78 if (smb2_data == NULL) {
79 rc = -ENOMEM;
80 goto out;
81 }
82
Pavel Shilovsky226730b2013-07-05 12:00:30 +040083 oparms->desired_access |= FILE_READ_ATTRIBUTES;
Pavel Shilovsky63eb3de2013-07-04 18:41:09 +040084 *smb2_oplock = SMB2_OPLOCK_LEVEL_BATCH;
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -070085
Pavel Shilovsky226730b2013-07-05 12:00:30 +040086 if (oparms->tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING)
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -070087 memcpy(smb2_oplock + 1, fid->lease_key, SMB2_LEASE_KEY_SIZE);
Pavel Shilovskyf0df7372012-09-18 16:20:26 -070088
Pavel Shilovsky064f6042013-07-09 18:20:30 +040089 rc = SMB2_open(xid, oparms, smb2_path, smb2_oplock, smb2_data);
Pavel Shilovskyf0df7372012-09-18 16:20:26 -070090 if (rc)
91 goto out;
92
93 if (buf) {
94 /* open response does not have IndexNumber field - get it */
Pavel Shilovsky226730b2013-07-05 12:00:30 +040095 rc = SMB2_get_srv_num(xid, oparms->tcon, fid->persistent_fid,
Pavel Shilovskyf0df7372012-09-18 16:20:26 -070096 fid->volatile_fid,
97 &smb2_data->IndexNumber);
98 if (rc) {
99 /* let get_inode_info disable server inode numbers */
100 smb2_data->IndexNumber = 0;
101 rc = 0;
102 }
103 move_smb2_info_to_cifs(buf, smb2_data);
104 }
105
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700106 *oplock = *smb2_oplock;
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700107out:
Pavel Shilovskyf0df7372012-09-18 16:20:26 -0700108 kfree(smb2_data);
109 kfree(smb2_path);
110 return rc;
111}
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -0700112
113int
114smb2_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
115 const unsigned int xid)
116{
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;
125
126 INIT_LIST_HEAD(&tmp_llist);
127
128 /*
129 * Accessing maxBuf is racy with cifs_reconnect - need to store value
130 * and check it for zero before using.
131 */
132 max_buf = tcon->ses->server->maxBuf;
133 if (!max_buf)
134 return -EINVAL;
135
136 max_num = max_buf / sizeof(struct smb2_lock_element);
137 buf = kzalloc(max_num * sizeof(struct smb2_lock_element), GFP_KERNEL);
138 if (!buf)
139 return -ENOMEM;
140
141 cur = buf;
142
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700143 down_write(&cinode->lock_sem);
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -0700144 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))
148 continue;
149 if (current->tgid != li->pid)
150 continue;
151 if (cinode->can_cache_brlcks) {
152 /*
153 * We can cache brlock requests - simply remove a lock
154 * from the file's list.
155 */
156 list_del(&li->llist);
157 cifs_del_lock_waiters(li);
158 kfree(li);
159 continue;
160 }
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);
164 /*
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.
167 */
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);
174 if (stored_rc) {
175 /*
176 * We failed on the unlock range request - add
177 * all locks from the tmp list to the head of
178 * the file's list.
179 */
180 cifs_move_llist(&tmp_llist,
181 &cfile->llist->locks);
182 rc = stored_rc;
183 } else
184 /*
185 * The unlock range request succeed - free the
186 * tmp list.
187 */
188 cifs_free_llist(&tmp_llist);
189 cur = buf;
190 num = 0;
191 } else
192 cur++;
193 }
194 if (num) {
195 stored_rc = smb2_lockv(xid, tcon, cfile->fid.persistent_fid,
196 cfile->fid.volatile_fid, current->tgid,
197 num, buf);
198 if (stored_rc) {
199 cifs_move_llist(&tmp_llist, &cfile->llist->locks);
200 rc = stored_rc;
201 } else
202 cifs_free_llist(&tmp_llist);
203 }
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700204 up_write(&cinode->lock_sem);
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -0700205
206 kfree(buf);
207 return rc;
208}
Pavel Shilovskyb1407992012-09-19 06:22:44 -0700209
210static int
211smb2_push_mand_fdlocks(struct cifs_fid_locks *fdlocks, const unsigned int xid,
212 struct smb2_lock_element *buf, unsigned int max_num)
213{
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);
220
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);
231 if (stored_rc)
232 rc = stored_rc;
233 cur = buf;
234 num = 0;
235 } else
236 cur++;
237 }
238 if (num) {
239 stored_rc = smb2_lockv(xid, tcon,
240 cfile->fid.persistent_fid,
241 cfile->fid.volatile_fid,
242 current->tgid, num, buf);
243 if (stored_rc)
244 rc = stored_rc;
245 }
246
247 return rc;
248}
249
250int
251smb2_push_mandatory_locks(struct cifsFileInfo *cfile)
252{
253 int rc = 0, stored_rc;
254 unsigned int xid;
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;
259
260 xid = get_xid();
Pavel Shilovskyb1407992012-09-19 06:22:44 -0700261
262 /*
263 * Accessing maxBuf is racy with cifs_reconnect - need to store value
264 * and check it for zero before using.
265 */
266 max_buf = tlink_tcon(cfile->tlink)->ses->server->maxBuf;
267 if (!max_buf) {
Pavel Shilovskyb1407992012-09-19 06:22:44 -0700268 free_xid(xid);
269 return -EINVAL;
270 }
271
272 max_num = max_buf / sizeof(struct smb2_lock_element);
273 buf = kzalloc(max_num * sizeof(struct smb2_lock_element), GFP_KERNEL);
274 if (!buf) {
Pavel Shilovskyb1407992012-09-19 06:22:44 -0700275 free_xid(xid);
276 return -ENOMEM;
277 }
278
279 list_for_each_entry(fdlocks, &cinode->llist, llist) {
280 stored_rc = smb2_push_mand_fdlocks(fdlocks, xid, buf, max_num);
281 if (stored_rc)
282 rc = stored_rc;
283 }
284
Pavel Shilovskyb1407992012-09-19 06:22:44 -0700285 kfree(buf);
Pavel Shilovskyb1407992012-09-19 06:22:44 -0700286 free_xid(xid);
287 return rc;
288}