fs/cifs/smb2inode.c

   1 // SPDX-License-Identifier: LGPL-2.1
   2 /*
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002, 2011
   5  *                 Etersoft, 2012
   6  *   Author(s): Pavel Shilovsky (pshilovsky@samba.org),
   7  *              Steve French (sfrench@us.ibm.com)
   8  *
   9  */
  10 #include <linux/fs.h>
  11 #include <linux/stat.h>
  12 #include <linux/slab.h>
  13 #include <linux/pagemap.h>
  14 #include <asm/div64.h>
  15 #include "cifsfs.h"
  16 #include "cifspdu.h"
  17 #include "cifsglob.h"
  18 #include "cifsproto.h"
  19 #include "cifs_debug.h"
  20 #include "cifs_fs_sb.h"
  21 #include "cifs_unicode.h"
  22 #include "fscache.h"
  23 #include "smb2glob.h"
  24 #include "smb2pdu.h"
  25 #include "smb2proto.h"
  26 #include "cached_dir.h"
  27 #include "smb2status.h"
  28
  29 static void
  30 free_set_inf_compound(struct smb_rqst *rqst)
  31 {
  32         if (rqst[1].rq_iov)
  33                 SMB2_set_info_free(&rqst[1]);
  34         if (rqst[2].rq_iov)
  35                 SMB2_close_free(&rqst[2]);
  36 }
  37
  38
  39 struct cop_vars {
  40         struct cifs_open_parms oparms;
  41         struct kvec rsp_iov[3];
  42         struct smb_rqst rqst[3];
  43         struct kvec open_iov[SMB2_CREATE_IOV_SIZE];
  44         struct kvec qi_iov[1];
  45         struct kvec si_iov[SMB2_SET_INFO_IOV_SIZE];
  46         struct kvec close_iov[1];
  47         struct smb2_file_rename_info rename_info;
  48         struct smb2_file_link_info link_info;
  49 };
  50
  51 /*
  52  * note: If cfile is passed, the reference to it is dropped here.
  53  * So make sure that you do not reuse cfile after return from this func.
  54  *
  55  * If passing @err_iov and @err_buftype, ensure to make them both large enough (>= 3) to hold all
  56  * error responses.  Caller is also responsible for freeing them up.
  57  */
  58 static int smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon,
  59                             struct cifs_sb_info *cifs_sb, const char *full_path,
  60                             __u32 desired_access, __u32 create_disposition, __u32 create_options,
  61                             umode_t mode, void *ptr, int command, struct cifsFileInfo *cfile,
  62                             struct kvec *err_iov, int *err_buftype)
  63 {
  64         struct cop_vars *vars = NULL;
  65         struct kvec *rsp_iov;
  66         struct smb_rqst *rqst;
  67         int rc;
  68         __le16 *utf16_path = NULL;
  69         __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
  70         struct cifs_fid fid;
  71         struct cifs_ses *ses = tcon->ses;
  72         struct TCP_Server_Info *server;
  73         int num_rqst = 0;
  74         int resp_buftype[3];
  75         struct smb2_query_info_rsp *qi_rsp = NULL;
  76         struct cifs_open_info_data *idata;
  77         int flags = 0;
  78         __u8 delete_pending[8] = {1, 0, 0, 0, 0, 0, 0, 0};
  79         unsigned int size[2];
  80         void *data[2];
  81         int len;
  82
  83         vars = kzalloc(sizeof(*vars), GFP_ATOMIC);
  84         if (vars == NULL)
  85                 return -ENOMEM;
  86         rqst = &vars->rqst[0];
  87         rsp_iov = &vars->rsp_iov[0];
  88
  89         server = cifs_pick_channel(ses);
  90
  91         if (smb3_encryption_required(tcon))
  92                 flags |= CIFS_TRANSFORM_REQ;
  93
  94         resp_buftype[0] = resp_buftype[1] = resp_buftype[2] = CIFS_NO_BUFFER;
  95
  96         /* We already have a handle so we can skip the open */
  97         if (cfile)
  98                 goto after_open;
  99
 100         /* Open */
 101         utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
 102         if (!utf16_path) {
 103                 rc = -ENOMEM;
 104                 goto finished;
 105         }
 106
 107         vars->oparms = (struct cifs_open_parms) {
 108                 .tcon = tcon,
 109                 .path = full_path,
 110                 .desired_access = desired_access,
 111                 .disposition = create_disposition,
 112                 .create_options = cifs_create_options(cifs_sb, create_options),
 113                 .fid = &fid,
 114                 .mode = mode,
 115                 .cifs_sb = cifs_sb,
 116         };
 117
 118         rqst[num_rqst].rq_iov = &vars->open_iov[0];
 119         rqst[num_rqst].rq_nvec = SMB2_CREATE_IOV_SIZE;
 120         rc = SMB2_open_init(tcon, server,
 121                             &rqst[num_rqst], &oplock, &vars->oparms,
 122                             utf16_path);
 123         kfree(utf16_path);
 124         if (rc)
 125                 goto finished;
 126
 127         smb2_set_next_command(tcon, &rqst[num_rqst]);
 128  after_open:
 129         num_rqst++;
 130         rc = 0;
 131
 132         /* Operation */
 133         switch (command) {
 134         case SMB2_OP_QUERY_INFO:
 135                 rqst[num_rqst].rq_iov = &vars->qi_iov[0];
 136                 rqst[num_rqst].rq_nvec = 1;
 137
 138                 if (cfile)
 139                         rc = SMB2_query_info_init(tcon, server,
 140                                 &rqst[num_rqst],
 141                                 cfile->fid.persistent_fid,
 142                                 cfile->fid.volatile_fid,
 143                                 FILE_ALL_INFORMATION,
 144                                 SMB2_O_INFO_FILE, 0,
 145                                 sizeof(struct smb2_file_all_info) +
 146                                           PATH_MAX * 2, 0, NULL);
 147                 else {
 148                         rc = SMB2_query_info_init(tcon, server,
 149                                 &rqst[num_rqst],
 150                                 COMPOUND_FID,
 151                                 COMPOUND_FID,
 152                                 FILE_ALL_INFORMATION,
 153                                 SMB2_O_INFO_FILE, 0,
 154                                 sizeof(struct smb2_file_all_info) +
 155                                           PATH_MAX * 2, 0, NULL);
 156                         if (!rc) {
 157                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 158                                 smb2_set_related(&rqst[num_rqst]);
 159                         }
 160                 }
 161
 162                 if (rc)
 163                         goto finished;
 164                 num_rqst++;
 165                 trace_smb3_query_info_compound_enter(xid, ses->Suid, tcon->tid,
 166                                                      full_path);
 167                 break;
 168         case SMB2_OP_POSIX_QUERY_INFO:
 169                 rqst[num_rqst].rq_iov = &vars->qi_iov[0];
 170                 rqst[num_rqst].rq_nvec = 1;
 171
 172                 if (cfile)
 173                         rc = SMB2_query_info_init(tcon, server,
 174                                 &rqst[num_rqst],
 175                                 cfile->fid.persistent_fid,
 176                                 cfile->fid.volatile_fid,
 177                                 SMB_FIND_FILE_POSIX_INFO,
 178                                 SMB2_O_INFO_FILE, 0,
 179                                 /* TBD: fix following to allow for longer SIDs */
 180                                 sizeof(struct smb311_posix_qinfo *) + (PATH_MAX * 2) +
 181                                 (sizeof(struct cifs_sid) * 2), 0, NULL);
 182                 else {
 183                         rc = SMB2_query_info_init(tcon, server,
 184                                 &rqst[num_rqst],
 185                                 COMPOUND_FID,
 186                                 COMPOUND_FID,
 187                                 SMB_FIND_FILE_POSIX_INFO,
 188                                 SMB2_O_INFO_FILE, 0,
 189                                 sizeof(struct smb311_posix_qinfo *) + (PATH_MAX * 2) +
 190                                 (sizeof(struct cifs_sid) * 2), 0, NULL);
 191                         if (!rc) {
 192                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 193                                 smb2_set_related(&rqst[num_rqst]);
 194                         }
 195                 }
 196
 197                 if (rc)
 198                         goto finished;
 199                 num_rqst++;
 200                 trace_smb3_posix_query_info_compound_enter(xid, ses->Suid, tcon->tid, full_path);
 201                 break;
 202         case SMB2_OP_DELETE:
 203                 trace_smb3_delete_enter(xid, ses->Suid, tcon->tid, full_path);
 204                 break;
 205         case SMB2_OP_MKDIR:
 206                 /*
 207                  * Directories are created through parameters in the
 208                  * SMB2_open() call.
 209                  */
 210                 trace_smb3_mkdir_enter(xid, ses->Suid, tcon->tid, full_path);
 211                 break;
 212         case SMB2_OP_RMDIR:
 213                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
 214                 rqst[num_rqst].rq_nvec = 1;
 215
 216                 size[0] = 1; /* sizeof __u8 See MS-FSCC section 2.4.11 */
 217                 data[0] = &delete_pending[0];
 218
 219                 rc = SMB2_set_info_init(tcon, server,
 220                                         &rqst[num_rqst], COMPOUND_FID,
 221                                         COMPOUND_FID, current->tgid,
 222                                         FILE_DISPOSITION_INFORMATION,
 223                                         SMB2_O_INFO_FILE, 0, data, size);
 224                 if (rc)
 225                         goto finished;
 226                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 227                 smb2_set_related(&rqst[num_rqst++]);
 228                 trace_smb3_rmdir_enter(xid, ses->Suid, tcon->tid, full_path);
 229                 break;
 230         case SMB2_OP_SET_EOF:
 231                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
 232                 rqst[num_rqst].rq_nvec = 1;
 233
 234                 size[0] = 8; /* sizeof __le64 */
 235                 data[0] = ptr;
 236
 237                 if (cfile) {
 238                         rc = SMB2_set_info_init(tcon, server,
 239                                                 &rqst[num_rqst],
 240                                                 cfile->fid.persistent_fid,
 241                                                 cfile->fid.volatile_fid,
 242                                                 current->tgid,
 243                                                 FILE_END_OF_FILE_INFORMATION,
 244                                                 SMB2_O_INFO_FILE, 0,
 245                                                 data, size);
 246                 } else {
 247                         rc = SMB2_set_info_init(tcon, server,
 248                                                 &rqst[num_rqst],
 249                                                 COMPOUND_FID,
 250                                                 COMPOUND_FID,
 251                                                 current->tgid,
 252                                                 FILE_END_OF_FILE_INFORMATION,
 253                                                 SMB2_O_INFO_FILE, 0,
 254                                                 data, size);
 255                         if (!rc) {
 256                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 257                                 smb2_set_related(&rqst[num_rqst]);
 258                         }
 259                 }
 260                 if (rc)
 261                         goto finished;
 262                 num_rqst++;
 263                 trace_smb3_set_eof_enter(xid, ses->Suid, tcon->tid, full_path);
 264                 break;
 265         case SMB2_OP_SET_INFO:
 266                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
 267                 rqst[num_rqst].rq_nvec = 1;
 268
 269
 270                 size[0] = sizeof(FILE_BASIC_INFO);
 271                 data[0] = ptr;
 272
 273                 if (cfile)
 274                         rc = SMB2_set_info_init(tcon, server,
 275                                 &rqst[num_rqst],
 276                                 cfile->fid.persistent_fid,
 277                                 cfile->fid.volatile_fid, current->tgid,
 278                                 FILE_BASIC_INFORMATION,
 279                                 SMB2_O_INFO_FILE, 0, data, size);
 280                 else {
 281                         rc = SMB2_set_info_init(tcon, server,
 282                                 &rqst[num_rqst],
 283                                 COMPOUND_FID,
 284                                 COMPOUND_FID, current->tgid,
 285                                 FILE_BASIC_INFORMATION,
 286                                 SMB2_O_INFO_FILE, 0, data, size);
 287                         if (!rc) {
 288                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 289                                 smb2_set_related(&rqst[num_rqst]);
 290                         }
 291                 }
 292
 293                 if (rc)
 294                         goto finished;
 295                 num_rqst++;
 296                 trace_smb3_set_info_compound_enter(xid, ses->Suid, tcon->tid,
 297                                                    full_path);
 298                 break;
 299         case SMB2_OP_RENAME:
 300                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
 301                 rqst[num_rqst].rq_nvec = 2;
 302
 303                 len = (2 * UniStrnlen((wchar_t *)ptr, PATH_MAX));
 304
 305                 vars->rename_info.ReplaceIfExists = 1;
 306                 vars->rename_info.RootDirectory = 0;
 307                 vars->rename_info.FileNameLength = cpu_to_le32(len);
 308
 309                 size[0] = sizeof(struct smb2_file_rename_info);
 310                 data[0] = &vars->rename_info;
 311
 312                 size[1] = len + 2 /* null */;
 313                 data[1] = (__le16 *)ptr;
 314
 315                 if (cfile)
 316                         rc = SMB2_set_info_init(tcon, server,
 317                                                 &rqst[num_rqst],
 318                                                 cfile->fid.persistent_fid,
 319                                                 cfile->fid.volatile_fid,
 320                                         current->tgid, FILE_RENAME_INFORMATION,
 321                                         SMB2_O_INFO_FILE, 0, data, size);
 322                 else {
 323                         rc = SMB2_set_info_init(tcon, server,
 324                                         &rqst[num_rqst],
 325                                         COMPOUND_FID, COMPOUND_FID,
 326                                         current->tgid, FILE_RENAME_INFORMATION,
 327                                         SMB2_O_INFO_FILE, 0, data, size);
 328                         if (!rc) {
 329                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 330                                 smb2_set_related(&rqst[num_rqst]);
 331                         }
 332                 }
 333                 if (rc)
 334                         goto finished;
 335                 num_rqst++;
 336                 trace_smb3_rename_enter(xid, ses->Suid, tcon->tid, full_path);
 337                 break;
 338         case SMB2_OP_HARDLINK:
 339                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
 340                 rqst[num_rqst].rq_nvec = 2;
 341
 342                 len = (2 * UniStrnlen((wchar_t *)ptr, PATH_MAX));
 343
 344                 vars->link_info.ReplaceIfExists = 0;
 345                 vars->link_info.RootDirectory = 0;
 346                 vars->link_info.FileNameLength = cpu_to_le32(len);
 347
 348                 size[0] = sizeof(struct smb2_file_link_info);
 349                 data[0] = &vars->link_info;
 350
 351                 size[1] = len + 2 /* null */;
 352                 data[1] = (__le16 *)ptr;
 353
 354                 rc = SMB2_set_info_init(tcon, server,
 355                                         &rqst[num_rqst], COMPOUND_FID,
 356                                         COMPOUND_FID, current->tgid,
 357                                         FILE_LINK_INFORMATION,
 358                                         SMB2_O_INFO_FILE, 0, data, size);
 359                 if (rc)
 360                         goto finished;
 361                 smb2_set_next_command(tcon, &rqst[num_rqst]);
 362                 smb2_set_related(&rqst[num_rqst++]);
 363                 trace_smb3_hardlink_enter(xid, ses->Suid, tcon->tid, full_path);
 364                 break;
 365         default:
 366                 cifs_dbg(VFS, "Invalid command\n");
 367                 rc = -EINVAL;
 368         }
 369         if (rc)
 370                 goto finished;
 371
 372         /* We already have a handle so we can skip the close */
 373         if (cfile)
 374                 goto after_close;
 375         /* Close */
 376         flags |= CIFS_CP_CREATE_CLOSE_OP;
 377         rqst[num_rqst].rq_iov = &vars->close_iov[0];
 378         rqst[num_rqst].rq_nvec = 1;
 379         rc = SMB2_close_init(tcon, server,
 380                              &rqst[num_rqst], COMPOUND_FID,
 381                              COMPOUND_FID, false);
 382         smb2_set_related(&rqst[num_rqst]);
 383         if (rc)
 384                 goto finished;
 385  after_close:
 386         num_rqst++;
 387
 388         if (cfile) {
 389                 rc = compound_send_recv(xid, ses, server,
 390                                         flags, num_rqst - 2,
 391                                         &rqst[1], &resp_buftype[1],
 392                                         &rsp_iov[1]);
 393         } else
 394                 rc = compound_send_recv(xid, ses, server,
 395                                         flags, num_rqst,
 396                                         rqst, resp_buftype,
 397                                         rsp_iov);
 398
 399  finished:
 400         if (cfile)
 401                 cifsFileInfo_put(cfile);
 402
 403         SMB2_open_free(&rqst[0]);
 404         if (rc == -EREMCHG) {
 405                 pr_warn_once("server share %s deleted\n", tcon->tree_name);
 406                 tcon->need_reconnect = true;
 407         }
 408
 409         switch (command) {
 410         case SMB2_OP_QUERY_INFO:
 411                 idata = ptr;
 412                 if (rc == 0 && cfile && cfile->symlink_target) {
 413                         idata->symlink_target = kstrdup(cfile->symlink_target, GFP_KERNEL);
 414                         if (!idata->symlink_target)
 415                                 rc = -ENOMEM;
 416                 }
 417                 if (rc == 0) {
 418                         qi_rsp = (struct smb2_query_info_rsp *)
 419                                 rsp_iov[1].iov_base;
 420                         rc = smb2_validate_and_copy_iov(
 421                                 le16_to_cpu(qi_rsp->OutputBufferOffset),
 422                                 le32_to_cpu(qi_rsp->OutputBufferLength),
 423                                 &rsp_iov[1], sizeof(idata->fi), (char *)&idata->fi);
 424                 }
 425                 if (rqst[1].rq_iov)
 426                         SMB2_query_info_free(&rqst[1]);
 427                 if (rqst[2].rq_iov)
 428                         SMB2_close_free(&rqst[2]);
 429                 if (rc)
 430                         trace_smb3_query_info_compound_err(xid,  ses->Suid,
 431                                                 tcon->tid, rc);
 432                 else
 433                         trace_smb3_query_info_compound_done(xid, ses->Suid,
 434                                                 tcon->tid);
 435                 break;
 436         case SMB2_OP_POSIX_QUERY_INFO:
 437                 idata = ptr;
 438                 if (rc == 0 && cfile && cfile->symlink_target) {
 439                         idata->symlink_target = kstrdup(cfile->symlink_target, GFP_KERNEL);
 440                         if (!idata->symlink_target)
 441                                 rc = -ENOMEM;
 442                 }
 443                 if (rc == 0) {
 444                         qi_rsp = (struct smb2_query_info_rsp *)
 445                                 rsp_iov[1].iov_base;
 446                         rc = smb2_validate_and_copy_iov(
 447                                 le16_to_cpu(qi_rsp->OutputBufferOffset),
 448                                 le32_to_cpu(qi_rsp->OutputBufferLength),
 449                                 &rsp_iov[1], sizeof(idata->posix_fi) /* add SIDs */,
 450                                 (char *)&idata->posix_fi);
 451                 }
 452                 if (rqst[1].rq_iov)
 453                         SMB2_query_info_free(&rqst[1]);
 454                 if (rqst[2].rq_iov)
 455                         SMB2_close_free(&rqst[2]);
 456                 if (rc)
 457                         trace_smb3_posix_query_info_compound_err(xid,  ses->Suid, tcon->tid, rc);
 458                 else
 459                         trace_smb3_posix_query_info_compound_done(xid, ses->Suid, tcon->tid);
 460                 break;
 461         case SMB2_OP_DELETE:
 462                 if (rc)
 463                         trace_smb3_delete_err(xid,  ses->Suid, tcon->tid, rc);
 464                 else
 465                         trace_smb3_delete_done(xid, ses->Suid, tcon->tid);
 466                 if (rqst[1].rq_iov)
 467                         SMB2_close_free(&rqst[1]);
 468                 break;
 469         case SMB2_OP_MKDIR:
 470                 if (rc)
 471                         trace_smb3_mkdir_err(xid,  ses->Suid, tcon->tid, rc);
 472                 else
 473                         trace_smb3_mkdir_done(xid, ses->Suid, tcon->tid);
 474                 if (rqst[1].rq_iov)
 475                         SMB2_close_free(&rqst[1]);
 476                 break;
 477         case SMB2_OP_HARDLINK:
 478                 if (rc)
 479                         trace_smb3_hardlink_err(xid,  ses->Suid, tcon->tid, rc);
 480                 else
 481                         trace_smb3_hardlink_done(xid, ses->Suid, tcon->tid);
 482                 free_set_inf_compound(rqst);
 483                 break;
 484         case SMB2_OP_RENAME:
 485                 if (rc)
 486                         trace_smb3_rename_err(xid,  ses->Suid, tcon->tid, rc);
 487                 else
 488                         trace_smb3_rename_done(xid, ses->Suid, tcon->tid);
 489                 free_set_inf_compound(rqst);
 490                 break;
 491         case SMB2_OP_RMDIR:
 492                 if (rc)
 493                         trace_smb3_rmdir_err(xid,  ses->Suid, tcon->tid, rc);
 494                 else
 495                         trace_smb3_rmdir_done(xid, ses->Suid, tcon->tid);
 496                 free_set_inf_compound(rqst);
 497                 break;
 498         case SMB2_OP_SET_EOF:
 499                 if (rc)
 500                         trace_smb3_set_eof_err(xid,  ses->Suid, tcon->tid, rc);
 501                 else
 502                         trace_smb3_set_eof_done(xid, ses->Suid, tcon->tid);
 503                 free_set_inf_compound(rqst);
 504                 break;
 505         case SMB2_OP_SET_INFO:
 506                 if (rc)
 507                         trace_smb3_set_info_compound_err(xid,  ses->Suid,
 508                                                 tcon->tid, rc);
 509                 else
 510                         trace_smb3_set_info_compound_done(xid, ses->Suid,
 511                                                 tcon->tid);
 512                 free_set_inf_compound(rqst);
 513                 break;
 514         }
 515
 516         if (rc && err_iov && err_buftype) {
 517                 memcpy(err_iov, rsp_iov, 3 * sizeof(*err_iov));
 518                 memcpy(err_buftype, resp_buftype, 3 * sizeof(*err_buftype));
 519         } else {
 520                 free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
 521                 free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
 522                 free_rsp_buf(resp_buftype[2], rsp_iov[2].iov_base);
 523         }
 524         kfree(vars);
 525         return rc;
 526 }
 527
 528 int smb2_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
 529                          struct cifs_sb_info *cifs_sb, const char *full_path,
 530                          struct cifs_open_info_data *data, bool *adjust_tz, bool *reparse)
 531 {
 532         __u32 create_options = 0;
 533         struct cifsFileInfo *cfile;
 534         struct cached_fid *cfid = NULL;
 535         struct kvec err_iov[3] = {};
 536         int err_buftype[3] = {};
 537         bool islink;
 538         int rc, rc2;
 539
 540         *adjust_tz = false;
 541         *reparse = false;
 542
 543         if (strcmp(full_path, ""))
 544                 rc = -ENOENT;
 545         else
 546                 rc = open_cached_dir(xid, tcon, full_path, cifs_sb, false, &cfid);
 547         /* If it is a root and its handle is cached then use it */
 548         if (!rc) {
 549                 if (cfid->file_all_info_is_valid) {
 550                         memcpy(&data->fi, &cfid->file_all_info, sizeof(data->fi));
 551                 } else {
 552                         rc = SMB2_query_info(xid, tcon, cfid->fid.persistent_fid,
 553                                              cfid->fid.volatile_fid, &data->fi);
 554                 }
 555                 close_cached_dir(cfid);
 556                 return rc;
 557         }
 558
 559         cifs_get_readable_path(tcon, full_path, &cfile);
 560         rc = smb2_compound_op(xid, tcon, cifs_sb, full_path, FILE_READ_ATTRIBUTES, FILE_OPEN,
 561                               create_options, ACL_NO_MODE, data, SMB2_OP_QUERY_INFO, cfile,
 562                               err_iov, err_buftype);
 563         if (rc) {
 564                 struct smb2_hdr *hdr = err_iov[0].iov_base;
 565
 566                 if (unlikely(!hdr || err_buftype[0] == CIFS_NO_BUFFER))
 567                         goto out;
 568                 if (rc == -EOPNOTSUPP && hdr->Command == SMB2_CREATE &&
 569                     hdr->Status == STATUS_STOPPED_ON_SYMLINK) {
 570                         rc = smb2_parse_symlink_response(cifs_sb, err_iov,
 571                                                          &data->symlink_target);
 572                         if (rc)
 573                                 goto out;
 574
 575                         *reparse = true;
 576                         create_options |= OPEN_REPARSE_POINT;
 577
 578                         /* Failed on a symbolic link - query a reparse point info */
 579                         cifs_get_readable_path(tcon, full_path, &cfile);
 580                         rc = smb2_compound_op(xid, tcon, cifs_sb, full_path,
 581                                               FILE_READ_ATTRIBUTES, FILE_OPEN,
 582                                               create_options, ACL_NO_MODE, data,
 583                                               SMB2_OP_QUERY_INFO, cfile, NULL, NULL);
 584                         goto out;
 585                 } else if (rc != -EREMOTE && hdr->Status == STATUS_OBJECT_NAME_INVALID) {
 586                         rc2 = cifs_inval_name_dfs_link_error(xid, tcon, cifs_sb,
 587                                                              full_path, &islink);
 588                         if (rc2) {
 589                                 rc = rc2;
 590                                 goto out;
 591                         }
 592                         if (islink)
 593                                 rc = -EREMOTE;
 594                 }
 595                 if (rc == -EREMOTE && IS_ENABLED(CONFIG_CIFS_DFS_UPCALL) && cifs_sb &&
 596                     (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS))
 597                         rc = -EOPNOTSUPP;
 598         }
 599
 600 out:
 601         free_rsp_buf(err_buftype[0], err_iov[0].iov_base);
 602         free_rsp_buf(err_buftype[1], err_iov[1].iov_base);
 603         free_rsp_buf(err_buftype[2], err_iov[2].iov_base);
 604         return rc;
 605 }
 606
 607
 608 int smb311_posix_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
 609                                  struct cifs_sb_info *cifs_sb, const char *full_path,
 610                                  struct cifs_open_info_data *data, bool *adjust_tz, bool *reparse)
 611 {
 612         int rc;
 613         __u32 create_options = 0;
 614         struct cifsFileInfo *cfile;
 615         struct kvec err_iov[3] = {};
 616         int err_buftype[3] = {};
 617
 618         *adjust_tz = false;
 619         *reparse = false;
 620
 621         /*
 622          * BB TODO: Add support for using the cached root handle.
 623          * Create SMB2_query_posix_info worker function to do non-compounded query
 624          * when we already have an open file handle for this. For now this is fast enough
 625          * (always using the compounded version).
 626          */
 627
 628         cifs_get_readable_path(tcon, full_path, &cfile);
 629         rc = smb2_compound_op(xid, tcon, cifs_sb, full_path, FILE_READ_ATTRIBUTES, FILE_OPEN,
 630                               create_options, ACL_NO_MODE, data, SMB2_OP_POSIX_QUERY_INFO, cfile,
 631                               err_iov, err_buftype);
 632         if (rc == -EOPNOTSUPP) {
 633                 /* BB TODO: When support for special files added to Samba re-verify this path */
 634                 if (err_iov[0].iov_base && err_buftype[0] != CIFS_NO_BUFFER &&
 635                     ((struct smb2_hdr *)err_iov[0].iov_base)->Command == SMB2_CREATE &&
 636                     ((struct smb2_hdr *)err_iov[0].iov_base)->Status == STATUS_STOPPED_ON_SYMLINK) {
 637                         rc = smb2_parse_symlink_response(cifs_sb, err_iov, &data->symlink_target);
 638                         if (rc)
 639                                 goto out;
 640                 }
 641                 *reparse = true;
 642                 create_options |= OPEN_REPARSE_POINT;
 643
 644                 /* Failed on a symbolic link - query a reparse point info */
 645                 cifs_get_readable_path(tcon, full_path, &cfile);
 646                 rc = smb2_compound_op(xid, tcon, cifs_sb, full_path, FILE_READ_ATTRIBUTES,
 647                                       FILE_OPEN, create_options, ACL_NO_MODE, data,
 648                                       SMB2_OP_POSIX_QUERY_INFO, cfile, NULL, NULL);
 649         }
 650
 651 out:
 652         free_rsp_buf(err_buftype[0], err_iov[0].iov_base);
 653         free_rsp_buf(err_buftype[1], err_iov[1].iov_base);
 654         free_rsp_buf(err_buftype[2], err_iov[2].iov_base);
 655         return rc;
 656 }
 657
 658 int
 659 smb2_mkdir(const unsigned int xid, struct inode *parent_inode, umode_t mode,
 660            struct cifs_tcon *tcon, const char *name,
 661            struct cifs_sb_info *cifs_sb)
 662 {
 663         return smb2_compound_op(xid, tcon, cifs_sb, name,
 664                                 FILE_WRITE_ATTRIBUTES, FILE_CREATE,
 665                                 CREATE_NOT_FILE, mode, NULL, SMB2_OP_MKDIR,
 666                                 NULL, NULL, NULL);
 667 }
 668
 669 void
 670 smb2_mkdir_setinfo(struct inode *inode, const char *name,
 671                    struct cifs_sb_info *cifs_sb, struct cifs_tcon *tcon,
 672                    const unsigned int xid)
 673 {
 674         FILE_BASIC_INFO data;
 675         struct cifsInodeInfo *cifs_i;
 676         struct cifsFileInfo *cfile;
 677         u32 dosattrs;
 678         int tmprc;
 679
 680         memset(&data, 0, sizeof(data));
 681         cifs_i = CIFS_I(inode);
 682         dosattrs = cifs_i->cifsAttrs | ATTR_READONLY;
 683         data.Attributes = cpu_to_le32(dosattrs);
 684         cifs_get_writable_path(tcon, name, FIND_WR_ANY, &cfile);
 685         tmprc = smb2_compound_op(xid, tcon, cifs_sb, name,
 686                                  FILE_WRITE_ATTRIBUTES, FILE_CREATE,
 687                                  CREATE_NOT_FILE, ACL_NO_MODE,
 688                                  &data, SMB2_OP_SET_INFO, cfile, NULL, NULL);
 689         if (tmprc == 0)
 690                 cifs_i->cifsAttrs = dosattrs;
 691 }
 692
 693 int
 694 smb2_rmdir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
 695            struct cifs_sb_info *cifs_sb)
 696 {
 697         drop_cached_dir_by_name(xid, tcon, name, cifs_sb);
 698         return smb2_compound_op(xid, tcon, cifs_sb, name, DELETE, FILE_OPEN,
 699                                 CREATE_NOT_FILE, ACL_NO_MODE,
 700                                 NULL, SMB2_OP_RMDIR, NULL, NULL, NULL);
 701 }
 702
 703 int
 704 smb2_unlink(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
 705             struct cifs_sb_info *cifs_sb)
 706 {
 707         return smb2_compound_op(xid, tcon, cifs_sb, name, DELETE, FILE_OPEN,
 708                                 CREATE_DELETE_ON_CLOSE | OPEN_REPARSE_POINT,
 709                                 ACL_NO_MODE, NULL, SMB2_OP_DELETE, NULL, NULL, NULL);
 710 }
 711
 712 static int
 713 smb2_set_path_attr(const unsigned int xid, struct cifs_tcon *tcon,
 714                    const char *from_name, const char *to_name,
 715                    struct cifs_sb_info *cifs_sb, __u32 access, int command,
 716                    struct cifsFileInfo *cfile)
 717 {
 718         __le16 *smb2_to_name = NULL;
 719         int rc;
 720
 721         smb2_to_name = cifs_convert_path_to_utf16(to_name, cifs_sb);
 722         if (smb2_to_name == NULL) {
 723                 rc = -ENOMEM;
 724                 goto smb2_rename_path;
 725         }
 726         rc = smb2_compound_op(xid, tcon, cifs_sb, from_name, access,
 727                               FILE_OPEN, 0, ACL_NO_MODE, smb2_to_name,
 728                               command, cfile, NULL, NULL);
 729 smb2_rename_path:
 730         kfree(smb2_to_name);
 731         return rc;
 732 }
 733
 734 int
 735 smb2_rename_path(const unsigned int xid, struct cifs_tcon *tcon,
 736                  const char *from_name, const char *to_name,
 737                  struct cifs_sb_info *cifs_sb)
 738 {
 739         struct cifsFileInfo *cfile;
 740
 741         drop_cached_dir_by_name(xid, tcon, from_name, cifs_sb);
 742         cifs_get_writable_path(tcon, from_name, FIND_WR_WITH_DELETE, &cfile);
 743
 744         return smb2_set_path_attr(xid, tcon, from_name, to_name,
 745                                   cifs_sb, DELETE, SMB2_OP_RENAME, cfile);
 746 }
 747
 748 int
 749 smb2_create_hardlink(const unsigned int xid, struct cifs_tcon *tcon,
 750                      const char *from_name, const char *to_name,
 751                      struct cifs_sb_info *cifs_sb)
 752 {
 753         return smb2_set_path_attr(xid, tcon, from_name, to_name, cifs_sb,
 754                                   FILE_READ_ATTRIBUTES, SMB2_OP_HARDLINK,
 755                                   NULL);
 756 }
 757
 758 int
 759 smb2_set_path_size(const unsigned int xid, struct cifs_tcon *tcon,
 760                    const char *full_path, __u64 size,
 761                    struct cifs_sb_info *cifs_sb, bool set_alloc)
 762 {
 763         __le64 eof = cpu_to_le64(size);
 764         struct cifsFileInfo *cfile;
 765
 766         cifs_get_writable_path(tcon, full_path, FIND_WR_ANY, &cfile);
 767         return smb2_compound_op(xid, tcon, cifs_sb, full_path,
 768                                 FILE_WRITE_DATA, FILE_OPEN, 0, ACL_NO_MODE,
 769                                 &eof, SMB2_OP_SET_EOF, cfile, NULL, NULL);
 770 }
 771
 772 int
 773 smb2_set_file_info(struct inode *inode, const char *full_path,
 774                    FILE_BASIC_INFO *buf, const unsigned int xid)
 775 {
 776         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 777         struct tcon_link *tlink;
 778         struct cifs_tcon *tcon;
 779         struct cifsFileInfo *cfile;
 780         int rc;
 781
 782         if ((buf->CreationTime == 0) && (buf->LastAccessTime == 0) &&
 783             (buf->LastWriteTime == 0) && (buf->ChangeTime == 0) &&
 784             (buf->Attributes == 0))
 785                 return 0; /* would be a no op, no sense sending this */
 786
 787         tlink = cifs_sb_tlink(cifs_sb);
 788         if (IS_ERR(tlink))
 789                 return PTR_ERR(tlink);
 790         tcon = tlink_tcon(tlink);
 791
 792         cifs_get_writable_path(tcon, full_path, FIND_WR_ANY, &cfile);
 793         rc = smb2_compound_op(xid, tcon, cifs_sb, full_path,
 794                               FILE_WRITE_ATTRIBUTES, FILE_OPEN,
 795                               0, ACL_NO_MODE, buf, SMB2_OP_SET_INFO, cfile,
 796                               NULL, NULL);
 797         cifs_put_tlink(tlink);
 798         return rc;
 799 }