1/* 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 37int 38smb2_open_file(const unsigned int xid, struct cifs_open_parms *oparms, 39 __u32 *oplock, FILE_ALL_INFO *buf) 40{ 41 int rc; 42 __le16 *smb2_path; 43 struct smb2_file_all_info *smb2_data = NULL; 44 __u8 smb2_oplock[17]; 45 struct cifs_fid *fid = oparms->fid; 46 struct network_resiliency_req nr_ioctl_req; 47 48 smb2_path = cifs_convert_path_to_utf16(oparms->path, oparms->cifs_sb); 49 if (smb2_path == NULL) { 50 rc = -ENOMEM; 51 goto out; 52 } 53 54 smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + PATH_MAX * 2, 55 GFP_KERNEL); 56 if (smb2_data == NULL) { 57 rc = -ENOMEM; 58 goto out; 59 } 60 61 oparms->desired_access |= FILE_READ_ATTRIBUTES; 62 *smb2_oplock = SMB2_OPLOCK_LEVEL_BATCH; 63 64 if (oparms->tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING) 65 memcpy(smb2_oplock + 1, fid->lease_key, SMB2_LEASE_KEY_SIZE); 66 67 rc = SMB2_open(xid, oparms, smb2_path, smb2_oplock, smb2_data, NULL); 68 if (rc) 69 goto out; 70 71 72 if (oparms->tcon->use_resilient) { 73 nr_ioctl_req.Timeout = 0; /* use server default (120 seconds) */ 74 nr_ioctl_req.Reserved = 0; 75 rc = SMB2_ioctl(xid, oparms->tcon, fid->persistent_fid, 76 fid->volatile_fid, FSCTL_LMR_REQUEST_RESILIENCY, true, 77 (char *)&nr_ioctl_req, sizeof(nr_ioctl_req), 78 NULL, NULL /* no return info */); 79 if (rc == -EOPNOTSUPP) { 80 cifs_dbg(VFS, 81 "resiliency not supported by server, disabling\n"); 82 oparms->tcon->use_resilient = false; 83 } else if (rc) 84 cifs_dbg(FYI, "error %d setting resiliency\n", rc); 85 86 rc = 0; 87 } 88 89 if (buf) { 90 /* open response does not have IndexNumber field - get it */ 91 rc = SMB2_get_srv_num(xid, oparms->tcon, fid->persistent_fid, 92 fid->volatile_fid, 93 &smb2_data->IndexNumber); 94 if (rc) { 95 /* let get_inode_info disable server inode numbers */ 96 smb2_data->IndexNumber = 0; 97 rc = 0; 98 } 99 move_smb2_info_to_cifs(buf, smb2_data); 100 } 101 102 *oplock = *smb2_oplock; 103out: 104 kfree(smb2_data); 105 kfree(smb2_path); 106 return rc; 107} 108 109int 110smb2_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, 111 const unsigned int xid) 112{ 113 int rc = 0, stored_rc; 114 unsigned int max_num, num = 0, max_buf; 115 struct smb2_lock_element *buf, *cur; 116 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 117 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 118 struct cifsLockInfo *li, *tmp; 119 __u64 length = 1 + flock->fl_end - flock->fl_start; 120 struct list_head tmp_llist; 121 122 INIT_LIST_HEAD(&tmp_llist); 123 124 /* 125 * Accessing maxBuf is racy with cifs_reconnect - need to store value 126 * and check it for zero before using. 127 */ 128 max_buf = tcon->ses->server->maxBuf; 129 if (!max_buf) 130 return -EINVAL; 131 132 max_num = max_buf / sizeof(struct smb2_lock_element); 133 buf = kcalloc(max_num, sizeof(struct smb2_lock_element), GFP_KERNEL); 134 if (!buf) 135 return -ENOMEM; 136 137 cur = buf; 138 139 down_write(&cinode->lock_sem); 140 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) { 141 if (flock->fl_start > li->offset || 142 (flock->fl_start + length) < 143 (li->offset + li->length)) 144 continue; 145 if (current->tgid != li->pid) 146 continue; 147 if (cinode->can_cache_brlcks) { 148 /* 149 * We can cache brlock requests - simply remove a lock 150 * from the file's list. 151 */ 152 list_del(&li->llist); 153 cifs_del_lock_waiters(li); 154 kfree(li); 155 continue; 156 } 157 cur->Length = cpu_to_le64(li->length); 158 cur->Offset = cpu_to_le64(li->offset); 159 cur->Flags = cpu_to_le32(SMB2_LOCKFLAG_UNLOCK); 160 /* 161 * We need to save a lock here to let us add it again to the 162 * file's list if the unlock range request fails on the server. 163 */ 164 list_move(&li->llist, &tmp_llist); 165 if (++num == max_num) { 166 stored_rc = smb2_lockv(xid, tcon, 167 cfile->fid.persistent_fid, 168 cfile->fid.volatile_fid, 169 current->tgid, num, buf); 170 if (stored_rc) { 171 /* 172 * We failed on the unlock range request - add 173 * all locks from the tmp list to the head of 174 * the file's list. 175 */ 176 cifs_move_llist(&tmp_llist, 177 &cfile->llist->locks); 178 rc = stored_rc; 179 } else 180 /* 181 * The unlock range request succeed - free the 182 * tmp list. 183 */ 184 cifs_free_llist(&tmp_llist); 185 cur = buf; 186 num = 0; 187 } else 188 cur++; 189 } 190 if (num) { 191 stored_rc = smb2_lockv(xid, tcon, cfile->fid.persistent_fid, 192 cfile->fid.volatile_fid, current->tgid, 193 num, buf); 194 if (stored_rc) { 195 cifs_move_llist(&tmp_llist, &cfile->llist->locks); 196 rc = stored_rc; 197 } else 198 cifs_free_llist(&tmp_llist); 199 } 200 up_write(&cinode->lock_sem); 201 202 kfree(buf); 203 return rc; 204} 205 206static int 207smb2_push_mand_fdlocks(struct cifs_fid_locks *fdlocks, const unsigned int xid, 208 struct smb2_lock_element *buf, unsigned int max_num) 209{ 210 int rc = 0, stored_rc; 211 struct cifsFileInfo *cfile = fdlocks->cfile; 212 struct cifsLockInfo *li; 213 unsigned int num = 0; 214 struct smb2_lock_element *cur = buf; 215 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 216 217 list_for_each_entry(li, &fdlocks->locks, llist) { 218 cur->Length = cpu_to_le64(li->length); 219 cur->Offset = cpu_to_le64(li->offset); 220 cur->Flags = cpu_to_le32(li->type | 221 SMB2_LOCKFLAG_FAIL_IMMEDIATELY); 222 if (++num == max_num) { 223 stored_rc = smb2_lockv(xid, tcon, 224 cfile->fid.persistent_fid, 225 cfile->fid.volatile_fid, 226 current->tgid, num, buf); 227 if (stored_rc) 228 rc = stored_rc; 229 cur = buf; 230 num = 0; 231 } else 232 cur++; 233 } 234 if (num) { 235 stored_rc = smb2_lockv(xid, tcon, 236 cfile->fid.persistent_fid, 237 cfile->fid.volatile_fid, 238 current->tgid, num, buf); 239 if (stored_rc) 240 rc = stored_rc; 241 } 242 243 return rc; 244} 245 246int 247smb2_push_mandatory_locks(struct cifsFileInfo *cfile) 248{ 249 int rc = 0, stored_rc; 250 unsigned int xid; 251 unsigned int max_num, max_buf; 252 struct smb2_lock_element *buf; 253 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 254 struct cifs_fid_locks *fdlocks; 255 256 xid = get_xid(); 257 258 /* 259 * Accessing maxBuf is racy with cifs_reconnect - need to store value 260 * and check it for zero before using. 261 */ 262 max_buf = tlink_tcon(cfile->tlink)->ses->server->maxBuf; 263 if (!max_buf) { 264 free_xid(xid); 265 return -EINVAL; 266 } 267 268 max_num = max_buf / sizeof(struct smb2_lock_element); 269 buf = kcalloc(max_num, sizeof(struct smb2_lock_element), GFP_KERNEL); 270 if (!buf) { 271 free_xid(xid); 272 return -ENOMEM; 273 } 274 275 list_for_each_entry(fdlocks, &cinode->llist, llist) { 276 stored_rc = smb2_push_mand_fdlocks(fdlocks, xid, buf, max_num); 277 if (stored_rc) 278 rc = stored_rc; 279 } 280 281 kfree(buf); 282 free_xid(xid); 283 return rc; 284} 285