fs/cifs/smb2file.c

   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
  37 void
  38 smb2_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock)
  39 {
  40         oplock &= 0xFF;
  41         if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE)
  42                 return;
  43         if (oplock == SMB2_OPLOCK_LEVEL_BATCH) {
  44                 cinode->oplock = CIFS_CACHE_READ_FLG | CIFS_CACHE_WRITE_FLG |
  45                                  CIFS_CACHE_HANDLE_FLG;
  46                 cifs_dbg(FYI, "Batch Oplock granted on inode %p\n",
  47                          &cinode->vfs_inode);
  48         } else if (oplock == SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
  49                 cinode->oplock = CIFS_CACHE_READ_FLG | CIFS_CACHE_WRITE_FLG;
  50                 cifs_dbg(FYI, "Exclusive Oplock granted on inode %p\n",
  51                          &cinode->vfs_inode);
  52         } else if (oplock == SMB2_OPLOCK_LEVEL_II) {
  53                 cinode->oplock = CIFS_CACHE_READ_FLG;
  54                 cifs_dbg(FYI, "Level II Oplock granted on inode %p\n",
  55                          &cinode->vfs_inode);
  56         } else
  57                 cinode->oplock = 0;
  58 }
  59
  60 int
  61 smb2_open_file(const unsigned int xid, struct cifs_open_parms *oparms,
  62                __u32 *oplock, FILE_ALL_INFO *buf)
  63 {
  64         int rc;
  65         __le16 *smb2_path;
  66         struct smb2_file_all_info *smb2_data = NULL;
  67         __u8 smb2_oplock[17];
  68         struct cifs_fid *fid = oparms->fid;
  69
  70         smb2_path = cifs_convert_path_to_utf16(oparms->path, oparms->cifs_sb);
  71         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
  83         oparms->desired_access |= FILE_READ_ATTRIBUTES;
  84         *smb2_oplock = SMB2_OPLOCK_LEVEL_BATCH;
  85
  86         if (oparms->tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING)
  87                 memcpy(smb2_oplock + 1, fid->lease_key, SMB2_LEASE_KEY_SIZE);
  88
  89         rc = SMB2_open(xid, oparms, smb2_path, smb2_oplock, smb2_data, NULL);
  90         if (rc)
  91                 goto out;
  92
  93         if (buf) {
  94                 /* open response does not have IndexNumber field - get it */
  95                 rc = SMB2_get_srv_num(xid, oparms->tcon, fid->persistent_fid,
  96                                       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
 106         *oplock = *smb2_oplock;
 107 out:
 108         kfree(smb2_data);
 109         kfree(smb2_path);
 110         return rc;
 111 }
 112
 113 int
 114 smb2_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
 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))
 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         }
 204         up_write(&cinode->lock_sem);
 205
 206         kfree(buf);
 207         return rc;
 208 }
 209
 210 static int
 211 smb2_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
 250 int
 251 smb2_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();
 261
 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) {
 268                 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) {
 275                 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
 285         kfree(buf);
 286         free_xid(xid);
 287         return rc;
 288 }