1 // SPDX-License-Identifier: LGPL-2.1 2 /* 3 * 4 * Copyright (C) International Business Machines Corp., 2002,2010 5 * Author(s): Steve French (sfrench@us.ibm.com) 6 * 7 */ 8 #include <linux/fs.h> 9 #include <linux/fs_struct.h> 10 #include <linux/stat.h> 11 #include <linux/slab.h> 12 #include <linux/pagemap.h> 13 #include <linux/freezer.h> 14 #include <linux/sched/signal.h> 15 #include <linux/wait_bit.h> 16 #include <linux/fiemap.h> 17 #include <asm/div64.h> 18 #include "cifsfs.h" 19 #include "cifsglob.h" 20 #include "cifsproto.h" 21 #include "smb2proto.h" 22 #include "cifs_debug.h" 23 #include "cifs_fs_sb.h" 24 #include "cifs_unicode.h" 25 #include "fscache.h" 26 #include "fs_context.h" 27 #include "cifs_ioctl.h" 28 #include "cached_dir.h" 29 #include "reparse.h" 30 31 /* 32 * Set parameters for the netfs library 33 */ 34 static void cifs_set_netfs_context(struct inode *inode) 35 { 36 struct cifsInodeInfo *cifs_i = CIFS_I(inode); 37 38 netfs_inode_init(&cifs_i->netfs, &cifs_req_ops, true); 39 } 40 41 static void cifs_set_ops(struct inode *inode) 42 { 43 struct cifs_sb_info *cifs_sb = CIFS_SB(inode); 44 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 45 struct netfs_inode *ictx = netfs_inode(inode); 46 unsigned int sbflags = cifs_sb_flags(cifs_sb); 47 48 switch (inode->i_mode & S_IFMT) { 49 case S_IFREG: 50 inode->i_op = &cifs_file_inode_ops; 51 if (sbflags & CIFS_MOUNT_DIRECT_IO) { 52 set_bit(NETFS_ICTX_UNBUFFERED, &ictx->flags); 53 if (sbflags & CIFS_MOUNT_NO_BRL) 54 inode->i_fop = &cifs_file_direct_nobrl_ops; 55 else 56 inode->i_fop = &cifs_file_direct_ops; 57 } else if (sbflags & CIFS_MOUNT_STRICT_IO) { 58 if (sbflags & CIFS_MOUNT_NO_BRL) 59 inode->i_fop = &cifs_file_strict_nobrl_ops; 60 else 61 inode->i_fop = &cifs_file_strict_ops; 62 } else if (sbflags & CIFS_MOUNT_NO_BRL) 63 inode->i_fop = &cifs_file_nobrl_ops; 64 else { /* not direct, send byte range locks */ 65 inode->i_fop = &cifs_file_ops; 66 } 67 68 /* check if server can support readahead */ 69 if (tcon->ses->server->max_read < PAGE_SIZE + MAX_CIFS_HDR_SIZE) 70 inode->i_data.a_ops = &cifs_addr_ops_smallbuf; 71 else 72 inode->i_data.a_ops = &cifs_addr_ops; 73 mapping_set_large_folios(inode->i_mapping); 74 break; 75 case S_IFDIR: 76 if (IS_AUTOMOUNT(inode)) { 77 inode->i_op = &cifs_namespace_inode_operations; 78 } else { 79 inode->i_op = &cifs_dir_inode_ops; 80 inode->i_fop = &cifs_dir_ops; 81 } 82 break; 83 case S_IFLNK: 84 inode->i_op = &cifs_symlink_inode_ops; 85 break; 86 default: 87 init_special_inode(inode, inode->i_mode, inode->i_rdev); 88 break; 89 } 90 } 91 92 /* check inode attributes against fattr. If they don't match, tag the 93 * inode for cache invalidation 94 */ 95 static void 96 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr) 97 { 98 struct cifs_fscache_inode_coherency_data cd; 99 struct cifsInodeInfo *cifs_i = CIFS_I(inode); 100 struct timespec64 mtime; 101 102 cifs_dbg(FYI, "%s: revalidating inode %llu\n", 103 __func__, cifs_i->uniqueid); 104 105 if (inode_state_read_once(inode) & I_NEW) { 106 cifs_dbg(FYI, "%s: inode %llu is new\n", 107 __func__, cifs_i->uniqueid); 108 return; 109 } 110 111 /* don't bother with revalidation if we have an oplock */ 112 if (CIFS_CACHE_READ(cifs_i)) { 113 cifs_dbg(FYI, "%s: inode %llu is oplocked\n", 114 __func__, cifs_i->uniqueid); 115 return; 116 } 117 118 /* revalidate if mtime or size have changed */ 119 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode); 120 mtime = inode_get_mtime(inode); 121 if (timespec64_equal(&mtime, &fattr->cf_mtime) && 122 cifs_i->netfs.remote_i_size == fattr->cf_eof) { 123 cifs_dbg(FYI, "%s: inode %llu is unchanged\n", 124 __func__, cifs_i->uniqueid); 125 return; 126 } 127 128 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n", 129 __func__, cifs_i->uniqueid); 130 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags); 131 /* Invalidate fscache cookie */ 132 cifs_fscache_fill_coherency(&cifs_i->netfs.inode, &cd); 133 fscache_invalidate(cifs_inode_cookie(inode), &cd, i_size_read(inode), 0); 134 } 135 136 /* 137 * copy nlink to the inode, unless it wasn't provided. Provide 138 * sane values if we don't have an existing one and none was provided 139 */ 140 static void 141 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr) 142 { 143 /* 144 * if we're in a situation where we can't trust what we 145 * got from the server (readdir, some non-unix cases) 146 * fake reasonable values 147 */ 148 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) { 149 /* only provide fake values on a new inode */ 150 if (inode_state_read_once(inode) & I_NEW) { 151 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) 152 set_nlink(inode, 2); 153 else 154 set_nlink(inode, 1); 155 } 156 return; 157 } 158 159 /* we trust the server, so update it */ 160 set_nlink(inode, fattr->cf_nlink); 161 } 162 163 /* populate an inode with info from a cifs_fattr struct */ 164 int 165 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr, 166 bool from_readdir) 167 { 168 struct cifsInodeInfo *cifs_i = CIFS_I(inode); 169 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 170 171 if (!(inode_state_read_once(inode) & I_NEW) && 172 unlikely(inode_wrong_type(inode, fattr->cf_mode))) { 173 CIFS_I(inode)->time = 0; /* force reval */ 174 return -ESTALE; 175 } 176 if (inode_state_read_once(inode) & I_NEW) 177 CIFS_I(inode)->netfs.zero_point = fattr->cf_eof; 178 179 cifs_revalidate_cache(inode, fattr); 180 181 spin_lock(&inode->i_lock); 182 fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode); 183 fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode); 184 fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode); 185 /* we do not want atime to be less than mtime, it broke some apps */ 186 if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0) 187 inode_set_atime_to_ts(inode, fattr->cf_mtime); 188 else 189 inode_set_atime_to_ts(inode, fattr->cf_atime); 190 inode_set_mtime_to_ts(inode, fattr->cf_mtime); 191 inode_set_ctime_to_ts(inode, fattr->cf_ctime); 192 inode->i_rdev = fattr->cf_rdev; 193 cifs_nlink_fattr_to_inode(inode, fattr); 194 inode->i_uid = fattr->cf_uid; 195 inode->i_gid = fattr->cf_gid; 196 197 /* if dynperm is set, don't clobber existing mode */ 198 if ((inode_state_read(inode) & I_NEW) || 199 !(cifs_sb_flags(cifs_sb) & CIFS_MOUNT_DYNPERM)) 200 inode->i_mode = fattr->cf_mode; 201 202 cifs_i->cifsAttrs = fattr->cf_cifsattrs; 203 cifs_i->reparse_tag = fattr->cf_cifstag; 204 205 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL) 206 cifs_i->time = 0; 207 else 208 cifs_i->time = jiffies; 209 210 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING) 211 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags); 212 else 213 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags); 214 215 cifs_i->netfs.remote_i_size = fattr->cf_eof; 216 /* 217 * Can't safely change the file size here if the client is writing to 218 * it due to potential races. 219 */ 220 if (is_size_safe_to_change(cifs_i, fattr->cf_eof, from_readdir)) { 221 i_size_write(inode, fattr->cf_eof); 222 223 /* 224 * i_blocks is not related to (i_size / i_blksize), 225 * but instead 512 byte (2**9) size is required for 226 * calculating num blocks. 227 */ 228 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9; 229 } 230 231 if (S_ISLNK(fattr->cf_mode) && fattr->cf_symlink_target) { 232 kfree(cifs_i->symlink_target); 233 cifs_i->symlink_target = fattr->cf_symlink_target; 234 fattr->cf_symlink_target = NULL; 235 } 236 spin_unlock(&inode->i_lock); 237 238 if (fattr->cf_flags & CIFS_FATTR_JUNCTION) 239 inode->i_flags |= S_AUTOMOUNT; 240 if (inode_state_read_once(inode) & I_NEW) { 241 cifs_set_netfs_context(inode); 242 cifs_set_ops(inode); 243 } 244 return 0; 245 } 246 247 void 248 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr) 249 { 250 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 251 252 if (!(cifs_sb_flags(cifs_sb) & CIFS_MOUNT_SERVER_INUM)) 253 fattr->cf_uniqueid = iunique(sb, ROOT_I); 254 } 255 256 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */ 257 void 258 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info, 259 struct cifs_sb_info *cifs_sb) 260 { 261 unsigned int sbflags; 262 263 memset(fattr, 0, sizeof(*fattr)); 264 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId); 265 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes); 266 fattr->cf_eof = le64_to_cpu(info->EndOfFile); 267 268 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime); 269 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime); 270 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange); 271 /* old POSIX extensions don't get create time */ 272 273 fattr->cf_mode = le64_to_cpu(info->Permissions); 274 275 /* 276 * Since we set the inode type below we need to mask off 277 * to avoid strange results if bits set above. 278 */ 279 fattr->cf_mode &= ~S_IFMT; 280 switch (le32_to_cpu(info->Type)) { 281 case UNIX_FILE: 282 fattr->cf_mode |= S_IFREG; 283 fattr->cf_dtype = DT_REG; 284 break; 285 case UNIX_SYMLINK: 286 fattr->cf_mode |= S_IFLNK; 287 fattr->cf_dtype = DT_LNK; 288 break; 289 case UNIX_DIR: 290 fattr->cf_mode |= S_IFDIR; 291 fattr->cf_dtype = DT_DIR; 292 break; 293 case UNIX_CHARDEV: 294 fattr->cf_mode |= S_IFCHR; 295 fattr->cf_dtype = DT_CHR; 296 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor), 297 le64_to_cpu(info->DevMinor) & MINORMASK); 298 break; 299 case UNIX_BLOCKDEV: 300 fattr->cf_mode |= S_IFBLK; 301 fattr->cf_dtype = DT_BLK; 302 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor), 303 le64_to_cpu(info->DevMinor) & MINORMASK); 304 break; 305 case UNIX_FIFO: 306 fattr->cf_mode |= S_IFIFO; 307 fattr->cf_dtype = DT_FIFO; 308 break; 309 case UNIX_SOCKET: 310 fattr->cf_mode |= S_IFSOCK; 311 fattr->cf_dtype = DT_SOCK; 312 break; 313 default: 314 /* safest to call it a file if we do not know */ 315 fattr->cf_mode |= S_IFREG; 316 fattr->cf_dtype = DT_REG; 317 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type)); 318 break; 319 } 320 321 sbflags = cifs_sb_flags(cifs_sb); 322 fattr->cf_uid = cifs_sb->ctx->linux_uid; 323 if (!(sbflags & CIFS_MOUNT_OVERR_UID)) { 324 u64 id = le64_to_cpu(info->Uid); 325 if (id < ((uid_t)-1)) { 326 kuid_t uid = make_kuid(&init_user_ns, id); 327 if (uid_valid(uid)) 328 fattr->cf_uid = uid; 329 } 330 } 331 332 fattr->cf_gid = cifs_sb->ctx->linux_gid; 333 if (!(sbflags & CIFS_MOUNT_OVERR_GID)) { 334 u64 id = le64_to_cpu(info->Gid); 335 if (id < ((gid_t)-1)) { 336 kgid_t gid = make_kgid(&init_user_ns, id); 337 if (gid_valid(gid)) 338 fattr->cf_gid = gid; 339 } 340 } 341 342 fattr->cf_nlink = le64_to_cpu(info->Nlinks); 343 } 344 345 /* 346 * Fill a cifs_fattr struct with fake inode info. 347 * 348 * Needed to setup cifs_fattr data for the directory which is the 349 * junction to the new submount (ie to setup the fake directory 350 * which represents a DFS referral or reparse mount point). 351 */ 352 static void cifs_create_junction_fattr(struct cifs_fattr *fattr, 353 struct super_block *sb) 354 { 355 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 356 357 cifs_dbg(FYI, "%s: creating fake fattr\n", __func__); 358 359 memset(fattr, 0, sizeof(*fattr)); 360 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU; 361 fattr->cf_uid = cifs_sb->ctx->linux_uid; 362 fattr->cf_gid = cifs_sb->ctx->linux_gid; 363 ktime_get_coarse_real_ts64(&fattr->cf_mtime); 364 fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime; 365 fattr->cf_nlink = 2; 366 fattr->cf_flags = CIFS_FATTR_JUNCTION; 367 } 368 369 /* Update inode with final fattr data */ 370 static int update_inode_info(struct super_block *sb, 371 struct cifs_fattr *fattr, 372 struct inode **inode) 373 { 374 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 375 int rc = 0; 376 377 if (!*inode) { 378 *inode = cifs_iget(sb, fattr); 379 if (!*inode) 380 rc = -ENOMEM; 381 return rc; 382 } 383 /* We already have inode, update it. 384 * 385 * If file type or uniqueid is different, return error. 386 */ 387 if (unlikely((cifs_sb_flags(cifs_sb) & CIFS_MOUNT_SERVER_INUM) && 388 CIFS_I(*inode)->uniqueid != fattr->cf_uniqueid)) { 389 CIFS_I(*inode)->time = 0; /* force reval */ 390 return -ESTALE; 391 } 392 return cifs_fattr_to_inode(*inode, fattr, false); 393 } 394 395 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 396 static int 397 cifs_get_file_info_unix(struct file *filp) 398 { 399 int rc; 400 unsigned int xid; 401 FILE_UNIX_BASIC_INFO find_data; 402 struct cifs_fattr fattr = {}; 403 struct inode *inode = file_inode(filp); 404 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 405 struct cifsFileInfo *cfile = filp->private_data; 406 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 407 408 xid = get_xid(); 409 410 if (cfile->symlink_target) { 411 fattr.cf_symlink_target = kstrdup(cfile->symlink_target, GFP_KERNEL); 412 if (!fattr.cf_symlink_target) { 413 rc = -ENOMEM; 414 goto cifs_gfiunix_out; 415 } 416 } 417 418 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data); 419 if (!rc) { 420 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb); 421 } else if (rc == -EREMOTE) { 422 cifs_create_junction_fattr(&fattr, inode->i_sb); 423 } else 424 goto cifs_gfiunix_out; 425 426 rc = cifs_fattr_to_inode(inode, &fattr, false); 427 428 cifs_gfiunix_out: 429 free_xid(xid); 430 return rc; 431 } 432 433 static int cifs_get_unix_fattr(const unsigned char *full_path, 434 struct super_block *sb, 435 struct cifs_fattr *fattr, 436 struct inode **pinode, 437 const unsigned int xid) 438 { 439 struct TCP_Server_Info *server; 440 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 441 FILE_UNIX_BASIC_INFO find_data; 442 struct cifs_tcon *tcon; 443 struct tcon_link *tlink; 444 int rc, tmprc; 445 446 cifs_dbg(FYI, "Getting info on %s\n", full_path); 447 448 tlink = cifs_sb_tlink(cifs_sb); 449 if (IS_ERR(tlink)) 450 return PTR_ERR(tlink); 451 tcon = tlink_tcon(tlink); 452 server = tcon->ses->server; 453 454 /* could have done a find first instead but this returns more info */ 455 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data, 456 cifs_sb->local_nls, cifs_remap(cifs_sb)); 457 cifs_dbg(FYI, "%s: query path info: rc = %d\n", __func__, rc); 458 cifs_put_tlink(tlink); 459 460 if (!rc) { 461 cifs_unix_basic_to_fattr(fattr, &find_data, cifs_sb); 462 } else if (rc == -EREMOTE) { 463 cifs_create_junction_fattr(fattr, sb); 464 rc = 0; 465 } else { 466 return rc; 467 } 468 469 if (!*pinode) 470 cifs_fill_uniqueid(sb, fattr); 471 472 /* check for Minshall+French symlinks */ 473 if (cifs_sb_flags(cifs_sb) & CIFS_MOUNT_MF_SYMLINKS) { 474 tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path); 475 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc); 476 } 477 478 if (S_ISLNK(fattr->cf_mode) && !fattr->cf_symlink_target) { 479 if (!server->ops->query_symlink) 480 return -EOPNOTSUPP; 481 rc = server->ops->query_symlink(xid, tcon, 482 cifs_sb, full_path, 483 &fattr->cf_symlink_target); 484 cifs_dbg(FYI, "%s: query_symlink: %d\n", __func__, rc); 485 } 486 return rc; 487 } 488 489 int cifs_get_inode_info_unix(struct inode **pinode, 490 const unsigned char *full_path, 491 struct super_block *sb, unsigned int xid) 492 { 493 struct cifs_fattr fattr = {}; 494 int rc; 495 496 rc = cifs_get_unix_fattr(full_path, sb, &fattr, pinode, xid); 497 if (rc) 498 goto out; 499 500 rc = update_inode_info(sb, &fattr, pinode); 501 out: 502 kfree(fattr.cf_symlink_target); 503 return rc; 504 } 505 #else 506 static inline int cifs_get_unix_fattr(const unsigned char *full_path, 507 struct super_block *sb, 508 struct cifs_fattr *fattr, 509 struct inode **pinode, 510 const unsigned int xid) 511 { 512 return -EOPNOTSUPP; 513 } 514 515 int cifs_get_inode_info_unix(struct inode **pinode, 516 const unsigned char *full_path, 517 struct super_block *sb, unsigned int xid) 518 { 519 return -EOPNOTSUPP; 520 } 521 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 522 523 static int 524 cifs_sfu_type(struct cifs_fattr *fattr, const char *path, 525 struct cifs_sb_info *cifs_sb, unsigned int xid) 526 { 527 int rc; 528 __u32 oplock; 529 struct tcon_link *tlink; 530 struct cifs_tcon *tcon; 531 struct cifs_fid fid; 532 struct cifs_open_parms oparms; 533 struct cifs_io_parms io_parms = {0}; 534 char *symlink_buf_utf16; 535 unsigned int symlink_len_utf16; 536 char buf[24]; 537 unsigned int bytes_read; 538 char *pbuf; 539 int buf_type = CIFS_NO_BUFFER; 540 541 pbuf = buf; 542 543 fattr->cf_mode &= ~S_IFMT; 544 545 if (fattr->cf_eof == 0) { 546 cifs_dbg(FYI, "Fifo\n"); 547 fattr->cf_mode |= S_IFIFO; 548 fattr->cf_dtype = DT_FIFO; 549 return 0; 550 } else if (fattr->cf_eof > 1 && fattr->cf_eof < 8) { 551 fattr->cf_mode |= S_IFREG; 552 fattr->cf_dtype = DT_REG; 553 return -EINVAL; /* EOPNOTSUPP? */ 554 } 555 556 tlink = cifs_sb_tlink(cifs_sb); 557 if (IS_ERR(tlink)) 558 return PTR_ERR(tlink); 559 tcon = tlink_tcon(tlink); 560 561 oparms = (struct cifs_open_parms) { 562 .tcon = tcon, 563 .cifs_sb = cifs_sb, 564 .desired_access = GENERIC_READ, 565 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR), 566 .disposition = FILE_OPEN, 567 .path = path, 568 .fid = &fid, 569 }; 570 571 if (tcon->ses->server->oplocks) 572 oplock = REQ_OPLOCK; 573 else 574 oplock = 0; 575 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL); 576 if (rc) { 577 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc); 578 cifs_put_tlink(tlink); 579 return rc; 580 } 581 582 /* Read header */ 583 io_parms.netfid = fid.netfid; 584 io_parms.pid = current->tgid; 585 io_parms.tcon = tcon; 586 io_parms.offset = 0; 587 io_parms.length = 24; 588 589 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms, 590 &bytes_read, &pbuf, &buf_type); 591 if ((rc == 0) && (bytes_read >= 8)) { 592 if (memcmp("IntxBLK\0", pbuf, 8) == 0) { 593 cifs_dbg(FYI, "Block device\n"); 594 fattr->cf_mode |= S_IFBLK; 595 fattr->cf_dtype = DT_BLK; 596 if (bytes_read == 24) { 597 /* we have enough to decode dev num */ 598 __u64 mjr; /* major */ 599 __u64 mnr; /* minor */ 600 mjr = le64_to_cpu(*(__le64 *)(pbuf+8)); 601 mnr = le64_to_cpu(*(__le64 *)(pbuf+16)); 602 fattr->cf_rdev = MKDEV(mjr, mnr); 603 } else if (bytes_read == 16) { 604 /* 605 * Windows NFS server before Windows Server 2012 606 * stores major and minor number in SFU-modified 607 * style, just as 32-bit numbers. Recognize it. 608 */ 609 __u32 mjr; /* major */ 610 __u32 mnr; /* minor */ 611 mjr = le32_to_cpu(*(__le32 *)(pbuf+8)); 612 mnr = le32_to_cpu(*(__le32 *)(pbuf+12)); 613 fattr->cf_rdev = MKDEV(mjr, mnr); 614 } 615 } else if (memcmp("IntxCHR\0", pbuf, 8) == 0) { 616 cifs_dbg(FYI, "Char device\n"); 617 fattr->cf_mode |= S_IFCHR; 618 fattr->cf_dtype = DT_CHR; 619 if (bytes_read == 24) { 620 /* we have enough to decode dev num */ 621 __u64 mjr; /* major */ 622 __u64 mnr; /* minor */ 623 mjr = le64_to_cpu(*(__le64 *)(pbuf+8)); 624 mnr = le64_to_cpu(*(__le64 *)(pbuf+16)); 625 fattr->cf_rdev = MKDEV(mjr, mnr); 626 } else if (bytes_read == 16) { 627 /* 628 * Windows NFS server before Windows Server 2012 629 * stores major and minor number in SFU-modified 630 * style, just as 32-bit numbers. Recognize it. 631 */ 632 __u32 mjr; /* major */ 633 __u32 mnr; /* minor */ 634 mjr = le32_to_cpu(*(__le32 *)(pbuf+8)); 635 mnr = le32_to_cpu(*(__le32 *)(pbuf+12)); 636 fattr->cf_rdev = MKDEV(mjr, mnr); 637 } 638 } else if (memcmp("LnxSOCK", pbuf, 8) == 0) { 639 cifs_dbg(FYI, "Socket\n"); 640 fattr->cf_mode |= S_IFSOCK; 641 fattr->cf_dtype = DT_SOCK; 642 } else if (memcmp("IntxLNK\1", pbuf, 8) == 0) { 643 cifs_dbg(FYI, "Symlink\n"); 644 fattr->cf_mode |= S_IFLNK; 645 fattr->cf_dtype = DT_LNK; 646 if ((fattr->cf_eof > 8) && (fattr->cf_eof % 2 == 0)) { 647 symlink_buf_utf16 = kmalloc(fattr->cf_eof-8 + 1, GFP_KERNEL); 648 if (symlink_buf_utf16) { 649 io_parms.offset = 8; 650 io_parms.length = fattr->cf_eof-8 + 1; 651 buf_type = CIFS_NO_BUFFER; 652 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms, 653 &symlink_len_utf16, 654 &symlink_buf_utf16, 655 &buf_type); 656 /* 657 * Check that read buffer has valid length and does not 658 * contain UTF-16 null codepoint (via UniStrnlen() call) 659 * because Linux cannot process symlink with null byte. 660 */ 661 if ((rc == 0) && 662 (symlink_len_utf16 > 0) && 663 (symlink_len_utf16 < fattr->cf_eof-8 + 1) && 664 (symlink_len_utf16 % 2 == 0) && 665 (UniStrnlen((wchar_t *)symlink_buf_utf16, symlink_len_utf16/2) == symlink_len_utf16/2)) { 666 fattr->cf_symlink_target = 667 cifs_strndup_from_utf16(symlink_buf_utf16, 668 symlink_len_utf16, 669 true, 670 cifs_sb->local_nls); 671 if (!fattr->cf_symlink_target) 672 rc = -ENOMEM; 673 } 674 kfree(symlink_buf_utf16); 675 } else { 676 rc = -ENOMEM; 677 } 678 } 679 } else if (memcmp("LnxFIFO", pbuf, 8) == 0) { 680 cifs_dbg(FYI, "FIFO\n"); 681 fattr->cf_mode |= S_IFIFO; 682 fattr->cf_dtype = DT_FIFO; 683 } else { 684 fattr->cf_mode |= S_IFREG; /* file? */ 685 fattr->cf_dtype = DT_REG; 686 rc = -EOPNOTSUPP; 687 } 688 } else if ((rc == 0) && (bytes_read == 1) && (pbuf[0] == '\0')) { 689 cifs_dbg(FYI, "Socket\n"); 690 fattr->cf_mode |= S_IFSOCK; 691 fattr->cf_dtype = DT_SOCK; 692 } else { 693 fattr->cf_mode |= S_IFREG; /* then it is a file */ 694 fattr->cf_dtype = DT_REG; 695 rc = -EOPNOTSUPP; /* or some unknown SFU type */ 696 } 697 698 tcon->ses->server->ops->close(xid, tcon, &fid); 699 cifs_put_tlink(tlink); 700 return rc; 701 } 702 703 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */ 704 705 /* 706 * Fetch mode bits as provided by SFU. 707 * 708 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ? 709 */ 710 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path, 711 struct cifs_sb_info *cifs_sb, unsigned int xid) 712 { 713 #ifdef CONFIG_CIFS_XATTR 714 ssize_t rc; 715 char ea_value[4]; 716 __u32 mode; 717 struct tcon_link *tlink; 718 struct cifs_tcon *tcon; 719 720 tlink = cifs_sb_tlink(cifs_sb); 721 if (IS_ERR(tlink)) 722 return PTR_ERR(tlink); 723 tcon = tlink_tcon(tlink); 724 725 if (tcon->ses->server->ops->query_all_EAs == NULL) { 726 cifs_put_tlink(tlink); 727 return -EOPNOTSUPP; 728 } 729 730 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path, 731 "SETFILEBITS", ea_value, 4 /* size of buf */, 732 cifs_sb); 733 cifs_put_tlink(tlink); 734 if (rc < 0) 735 return (int)rc; 736 else if (rc > 3) { 737 mode = le32_to_cpu(*((__le32 *)ea_value)); 738 fattr->cf_mode &= ~SFBITS_MASK; 739 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n", 740 mode, fattr->cf_mode); 741 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode; 742 cifs_dbg(FYI, "special mode bits 0%o\n", mode); 743 } 744 745 return 0; 746 #else 747 return -EOPNOTSUPP; 748 #endif 749 } 750 751 #define POSIX_TYPE_FILE 0 752 #define POSIX_TYPE_DIR 1 753 #define POSIX_TYPE_SYMLINK 2 754 #define POSIX_TYPE_CHARDEV 3 755 #define POSIX_TYPE_BLKDEV 4 756 #define POSIX_TYPE_FIFO 5 757 #define POSIX_TYPE_SOCKET 6 758 759 #define POSIX_X_OTH 0000001 760 #define POSIX_W_OTH 0000002 761 #define POSIX_R_OTH 0000004 762 #define POSIX_X_GRP 0000010 763 #define POSIX_W_GRP 0000020 764 #define POSIX_R_GRP 0000040 765 #define POSIX_X_USR 0000100 766 #define POSIX_W_USR 0000200 767 #define POSIX_R_USR 0000400 768 #define POSIX_STICKY 0001000 769 #define POSIX_SET_GID 0002000 770 #define POSIX_SET_UID 0004000 771 772 #define POSIX_OTH_MASK 0000007 773 #define POSIX_GRP_MASK 0000070 774 #define POSIX_USR_MASK 0000700 775 #define POSIX_PERM_MASK 0000777 776 #define POSIX_FILETYPE_MASK 0070000 777 778 #define POSIX_FILETYPE_SHIFT 12 779 780 static u32 wire_perms_to_posix(u32 wire) 781 { 782 u32 mode = 0; 783 784 mode |= (wire & POSIX_X_OTH) ? S_IXOTH : 0; 785 mode |= (wire & POSIX_W_OTH) ? S_IWOTH : 0; 786 mode |= (wire & POSIX_R_OTH) ? S_IROTH : 0; 787 mode |= (wire & POSIX_X_GRP) ? S_IXGRP : 0; 788 mode |= (wire & POSIX_W_GRP) ? S_IWGRP : 0; 789 mode |= (wire & POSIX_R_GRP) ? S_IRGRP : 0; 790 mode |= (wire & POSIX_X_USR) ? S_IXUSR : 0; 791 mode |= (wire & POSIX_W_USR) ? S_IWUSR : 0; 792 mode |= (wire & POSIX_R_USR) ? S_IRUSR : 0; 793 mode |= (wire & POSIX_STICKY) ? S_ISVTX : 0; 794 mode |= (wire & POSIX_SET_GID) ? S_ISGID : 0; 795 mode |= (wire & POSIX_SET_UID) ? S_ISUID : 0; 796 797 return mode; 798 } 799 800 static u32 posix_filetypes[] = { 801 S_IFREG, 802 S_IFDIR, 803 S_IFLNK, 804 S_IFCHR, 805 S_IFBLK, 806 S_IFIFO, 807 S_IFSOCK 808 }; 809 810 static u32 wire_filetype_to_posix(u32 wire_type) 811 { 812 if (wire_type >= ARRAY_SIZE(posix_filetypes)) { 813 pr_warn("Unexpected type %u", wire_type); 814 return 0; 815 } 816 return posix_filetypes[wire_type]; 817 } 818 819 umode_t wire_mode_to_posix(u32 wire, bool is_dir) 820 { 821 u32 wire_type; 822 u32 mode; 823 824 wire_type = (wire & POSIX_FILETYPE_MASK) >> POSIX_FILETYPE_SHIFT; 825 /* older servers do not set POSIX file type in the mode field in the response */ 826 if ((wire_type == 0) && is_dir) 827 mode = wire_perms_to_posix(wire) | S_IFDIR; 828 else 829 mode = (wire_perms_to_posix(wire) | wire_filetype_to_posix(wire_type)); 830 return (umode_t)mode; 831 } 832 833 /* Fill a cifs_fattr struct with info from POSIX info struct */ 834 static void smb311_posix_info_to_fattr(struct cifs_fattr *fattr, 835 struct cifs_open_info_data *data, 836 struct super_block *sb) 837 { 838 struct smb311_posix_qinfo *info = &data->posix_fi; 839 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 840 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 841 842 memset(fattr, 0, sizeof(*fattr)); 843 844 /* no fattr->flags to set */ 845 fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes); 846 fattr->cf_uniqueid = le64_to_cpu(info->Inode); 847 848 if (info->LastAccessTime) 849 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime); 850 else 851 ktime_get_coarse_real_ts64(&fattr->cf_atime); 852 853 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime); 854 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime); 855 856 if (data->adjust_tz) { 857 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj; 858 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj; 859 } 860 861 /* 862 * The srv fs device id is overridden on network mount so setting 863 * @fattr->cf_rdev isn't needed here. 864 */ 865 fattr->cf_eof = le64_to_cpu(info->EndOfFile); 866 fattr->cf_bytes = le64_to_cpu(info->AllocationSize); 867 fattr->cf_createtime = le64_to_cpu(info->CreationTime); 868 fattr->cf_nlink = le32_to_cpu(info->HardLinks); 869 fattr->cf_mode = wire_mode_to_posix(le32_to_cpu(info->Mode), 870 fattr->cf_cifsattrs & ATTR_DIRECTORY); 871 872 if (cifs_open_data_reparse(data) && 873 cifs_reparse_point_to_fattr(cifs_sb, fattr, data)) 874 goto out_reparse; 875 876 fattr->cf_dtype = S_DT(fattr->cf_mode); 877 878 out_reparse: 879 if (S_ISLNK(fattr->cf_mode)) { 880 if (likely(data->symlink_target)) 881 fattr->cf_eof = strnlen(data->symlink_target, PATH_MAX); 882 fattr->cf_symlink_target = data->symlink_target; 883 data->symlink_target = NULL; 884 } 885 sid_to_id(cifs_sb, &data->posix_owner, fattr, SIDOWNER); 886 sid_to_id(cifs_sb, &data->posix_group, fattr, SIDGROUP); 887 888 cifs_dbg(FYI, "POSIX query info: mode 0x%x uniqueid 0x%llx nlink %d\n", 889 fattr->cf_mode, fattr->cf_uniqueid, fattr->cf_nlink); 890 } 891 892 static void cifs_open_info_to_fattr(struct cifs_fattr *fattr, 893 struct cifs_open_info_data *data, 894 struct super_block *sb) 895 { 896 struct smb2_file_all_info *info = &data->fi; 897 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 898 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 899 900 memset(fattr, 0, sizeof(*fattr)); 901 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes); 902 if (info->DeletePending) 903 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING; 904 905 if (info->LastAccessTime) 906 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime); 907 else 908 ktime_get_coarse_real_ts64(&fattr->cf_atime); 909 910 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime); 911 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime); 912 913 if (data->adjust_tz) { 914 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj; 915 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj; 916 } 917 918 fattr->cf_eof = le64_to_cpu(info->EndOfFile); 919 fattr->cf_bytes = le64_to_cpu(info->AllocationSize); 920 fattr->cf_createtime = le64_to_cpu(info->CreationTime); 921 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks); 922 fattr->cf_uid = cifs_sb->ctx->linux_uid; 923 fattr->cf_gid = cifs_sb->ctx->linux_gid; 924 925 fattr->cf_mode = cifs_sb->ctx->file_mode; 926 if (cifs_open_data_reparse(data) && 927 cifs_reparse_point_to_fattr(cifs_sb, fattr, data)) 928 goto out_reparse; 929 930 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) { 931 fattr->cf_mode = S_IFDIR | cifs_sb->ctx->dir_mode; 932 fattr->cf_dtype = DT_DIR; 933 /* 934 * Server can return wrong NumberOfLinks value for directories 935 * when Unix extensions are disabled - fake it. 936 */ 937 if (!tcon->unix_ext) 938 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK; 939 } else { 940 fattr->cf_mode = S_IFREG | cifs_sb->ctx->file_mode; 941 fattr->cf_dtype = DT_REG; 942 943 /* 944 * Don't accept zero nlink from non-unix servers unless 945 * delete is pending. Instead mark it as unknown. 946 */ 947 if ((fattr->cf_nlink < 1) && !tcon->unix_ext && 948 !info->DeletePending) { 949 cifs_dbg(VFS, "bogus file nlink value %u\n", 950 fattr->cf_nlink); 951 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK; 952 } 953 } 954 955 /* clear write bits if ATTR_READONLY is set */ 956 if (fattr->cf_cifsattrs & ATTR_READONLY) 957 fattr->cf_mode &= ~(S_IWUGO); 958 959 out_reparse: 960 if (S_ISLNK(fattr->cf_mode)) { 961 if (likely(data->symlink_target)) 962 fattr->cf_eof = strnlen(data->symlink_target, PATH_MAX); 963 fattr->cf_symlink_target = data->symlink_target; 964 data->symlink_target = NULL; 965 } 966 } 967 968 static int 969 cifs_get_file_info(struct file *filp) 970 { 971 int rc; 972 unsigned int xid; 973 struct cifs_open_info_data data = {}; 974 struct cifs_fattr fattr; 975 struct inode *inode = file_inode(filp); 976 struct cifsFileInfo *cfile = filp->private_data; 977 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 978 struct TCP_Server_Info *server = tcon->ses->server; 979 struct dentry *dentry = filp->f_path.dentry; 980 void *page = alloc_dentry_path(); 981 const unsigned char *path; 982 983 if (!server->ops->query_file_info) { 984 free_dentry_path(page); 985 return -ENOSYS; 986 } 987 988 xid = get_xid(); 989 rc = server->ops->query_file_info(xid, tcon, cfile, &data); 990 switch (rc) { 991 case 0: 992 /* TODO: add support to query reparse tag */ 993 data.adjust_tz = false; 994 if (data.symlink_target) { 995 data.reparse_point = true; 996 data.reparse.tag = IO_REPARSE_TAG_SYMLINK; 997 } 998 path = build_path_from_dentry(dentry, page); 999 if (IS_ERR(path)) { 1000 rc = PTR_ERR(path); 1001 goto cgfi_exit; 1002 } 1003 cifs_open_info_to_fattr(&fattr, &data, inode->i_sb); 1004 if (fattr.cf_flags & CIFS_FATTR_DELETE_PENDING) 1005 cifs_mark_open_handles_for_deleted_file(inode, path); 1006 break; 1007 case -EREMOTE: 1008 cifs_create_junction_fattr(&fattr, inode->i_sb); 1009 break; 1010 case -EOPNOTSUPP: 1011 case -EINVAL: 1012 /* 1013 * FIXME: legacy server -- fall back to path-based call? 1014 * for now, just skip revalidating and mark inode for 1015 * immediate reval. 1016 */ 1017 rc = 0; 1018 CIFS_I(inode)->time = 0; 1019 goto cgfi_exit; 1020 default: 1021 goto cgfi_exit; 1022 } 1023 1024 /* 1025 * don't bother with SFU junk here -- just mark inode as needing 1026 * revalidation. 1027 */ 1028 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid; 1029 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL; 1030 /* if filetype is different, return error */ 1031 rc = cifs_fattr_to_inode(inode, &fattr, false); 1032 cgfi_exit: 1033 cifs_free_open_info(&data); 1034 free_dentry_path(page); 1035 free_xid(xid); 1036 return rc; 1037 } 1038 1039 /* Simple function to return a 64 bit hash of string. Rarely called */ 1040 static __u64 simple_hashstr(const char *str) 1041 { 1042 const __u64 hash_mult = 1125899906842597ULL; /* a big enough prime */ 1043 __u64 hash = 0; 1044 1045 while (*str) 1046 hash = (hash + (__u64) *str++) * hash_mult; 1047 1048 return hash; 1049 } 1050 1051 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1052 /** 1053 * cifs_backup_query_path_info - SMB1 fallback code to get ino 1054 * 1055 * Fallback code to get file metadata when we don't have access to 1056 * full_path (EACCES) and have backup creds. 1057 * 1058 * @xid: transaction id used to identify original request in logs 1059 * @tcon: information about the server share we have mounted 1060 * @sb: the superblock stores info such as disk space available 1061 * @full_path: name of the file we are getting the metadata for 1062 * @resp_buf: will be set to cifs resp buf and needs to be freed with 1063 * cifs_buf_release() when done with @data 1064 * @data: will be set to search info result buffer 1065 */ 1066 static int 1067 cifs_backup_query_path_info(int xid, 1068 struct cifs_tcon *tcon, 1069 struct super_block *sb, 1070 const char *full_path, 1071 void **resp_buf, 1072 FILE_ALL_INFO **data) 1073 { 1074 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 1075 struct cifs_search_info info = {0}; 1076 u16 flags; 1077 int rc; 1078 1079 *resp_buf = NULL; 1080 info.endOfSearch = false; 1081 if (tcon->unix_ext) 1082 info.info_level = SMB_FIND_FILE_UNIX; 1083 else if ((tcon->ses->capabilities & 1084 tcon->ses->server->vals->cap_nt_find) == 0) 1085 info.info_level = SMB_FIND_FILE_INFO_STANDARD; 1086 else if (cifs_sb_flags(cifs_sb) & CIFS_MOUNT_SERVER_INUM) 1087 info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO; 1088 else /* no srvino useful for fallback to some netapp */ 1089 info.info_level = SMB_FIND_FILE_DIRECTORY_INFO; 1090 1091 flags = CIFS_SEARCH_CLOSE_ALWAYS | 1092 CIFS_SEARCH_CLOSE_AT_END | 1093 CIFS_SEARCH_BACKUP_SEARCH; 1094 1095 rc = CIFSFindFirst(xid, tcon, full_path, 1096 cifs_sb, NULL, flags, &info, false); 1097 if (rc) 1098 return rc; 1099 1100 *resp_buf = (void *)info.ntwrk_buf_start; 1101 *data = (FILE_ALL_INFO *)info.srch_entries_start; 1102 return 0; 1103 } 1104 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1105 1106 static void cifs_set_fattr_ino(int xid, struct cifs_tcon *tcon, struct super_block *sb, 1107 struct inode **inode, const char *full_path, 1108 struct cifs_open_info_data *data, struct cifs_fattr *fattr) 1109 { 1110 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 1111 struct TCP_Server_Info *server = tcon->ses->server; 1112 int rc; 1113 1114 if (!(cifs_sb_flags(cifs_sb) & CIFS_MOUNT_SERVER_INUM)) { 1115 if (*inode) 1116 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid; 1117 else 1118 fattr->cf_uniqueid = iunique(sb, ROOT_I); 1119 return; 1120 } 1121 1122 /* 1123 * If we have an inode pass a NULL tcon to ensure we don't 1124 * make a round trip to the server. This only works for SMB2+. 1125 */ 1126 rc = server->ops->get_srv_inum(xid, *inode ? NULL : tcon, cifs_sb, full_path, 1127 &fattr->cf_uniqueid, data); 1128 if (rc) { 1129 /* 1130 * If that fails reuse existing ino or generate one 1131 * and disable server ones 1132 */ 1133 if (*inode) 1134 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid; 1135 else { 1136 fattr->cf_uniqueid = iunique(sb, ROOT_I); 1137 cifs_autodisable_serverino(cifs_sb); 1138 } 1139 return; 1140 } 1141 1142 /* If no errors, check for zero root inode (invalid) */ 1143 if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) { 1144 cifs_dbg(FYI, "Invalid (0) inodenum\n"); 1145 if (*inode) { 1146 /* reuse */ 1147 fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid; 1148 } else { 1149 /* make an ino by hashing the UNC */ 1150 fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO; 1151 fattr->cf_uniqueid = simple_hashstr(tcon->tree_name); 1152 } 1153 } 1154 } 1155 1156 static inline bool is_inode_cache_good(struct inode *ino) 1157 { 1158 return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0; 1159 } 1160 1161 static int reparse_info_to_fattr(struct cifs_open_info_data *data, 1162 struct super_block *sb, 1163 const unsigned int xid, 1164 struct cifs_tcon *tcon, 1165 const char *full_path, 1166 struct cifs_fattr *fattr) 1167 { 1168 struct TCP_Server_Info *server = tcon->ses->server; 1169 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 1170 struct kvec rsp_iov, *iov = NULL; 1171 int rsp_buftype = CIFS_NO_BUFFER; 1172 u32 tag = data->reparse.tag; 1173 int rc = 0; 1174 1175 if (!tag && server->ops->query_reparse_point) { 1176 rc = server->ops->query_reparse_point(xid, tcon, cifs_sb, 1177 full_path, &tag, 1178 &rsp_iov, &rsp_buftype); 1179 if (!rc) 1180 iov = &rsp_iov; 1181 } else if (data->reparse.io.buftype != CIFS_NO_BUFFER && 1182 data->reparse.io.iov.iov_base) { 1183 iov = &data->reparse.io.iov; 1184 } 1185 1186 rc = -EOPNOTSUPP; 1187 data->reparse.tag = tag; 1188 if (!data->reparse.tag) { 1189 if (server->ops->query_symlink) { 1190 rc = server->ops->query_symlink(xid, tcon, 1191 cifs_sb, full_path, 1192 &data->symlink_target); 1193 } 1194 if (rc == -EOPNOTSUPP) 1195 data->reparse.tag = IO_REPARSE_TAG_INTERNAL; 1196 } 1197 1198 switch (data->reparse.tag) { 1199 case 0: /* SMB1 symlink */ 1200 break; 1201 case IO_REPARSE_TAG_INTERNAL: 1202 rc = 0; 1203 if (le32_to_cpu(data->fi.Attributes) & ATTR_DIRECTORY) { 1204 cifs_create_junction_fattr(fattr, sb); 1205 goto out; 1206 } 1207 break; 1208 default: 1209 /* Check for cached reparse point data */ 1210 if (data->symlink_target || data->reparse.buf) { 1211 rc = 0; 1212 } else if (iov && server->ops->get_reparse_point_buffer) { 1213 struct reparse_data_buffer *reparse_buf; 1214 u32 reparse_len; 1215 1216 reparse_buf = server->ops->get_reparse_point_buffer(iov, &reparse_len); 1217 rc = parse_reparse_point(reparse_buf, reparse_len, 1218 cifs_sb, full_path, data); 1219 /* 1220 * If the reparse point was not handled but it is the 1221 * name surrogate which points to directory, then treat 1222 * is as a new mount point. Name surrogate reparse point 1223 * represents another named entity in the system. 1224 */ 1225 if (rc == -EOPNOTSUPP && 1226 IS_REPARSE_TAG_NAME_SURROGATE(data->reparse.tag) && 1227 (le32_to_cpu(data->fi.Attributes) & ATTR_DIRECTORY)) { 1228 rc = 0; 1229 cifs_create_junction_fattr(fattr, sb); 1230 goto out; 1231 } 1232 /* 1233 * If the reparse point is unsupported by the Linux SMB 1234 * client then let it process by the SMB server. So mask 1235 * the -EOPNOTSUPP error code. This will allow Linux SMB 1236 * client to send SMB OPEN request to server. If server 1237 * does not support this reparse point too then server 1238 * will return error during open the path. 1239 */ 1240 if (rc == -EOPNOTSUPP) 1241 rc = 0; 1242 } 1243 1244 if (data->reparse.tag == IO_REPARSE_TAG_SYMLINK && !rc) { 1245 bool directory = le32_to_cpu(data->fi.Attributes) & ATTR_DIRECTORY; 1246 rc = smb2_fix_symlink_target_type(&data->symlink_target, directory, cifs_sb); 1247 } 1248 break; 1249 } 1250 1251 if (tcon->posix_extensions) 1252 smb311_posix_info_to_fattr(fattr, data, sb); 1253 else 1254 cifs_open_info_to_fattr(fattr, data, sb); 1255 out: 1256 fattr->cf_cifstag = data->reparse.tag; 1257 free_rsp_buf(rsp_buftype, rsp_iov.iov_base); 1258 return rc; 1259 } 1260 1261 static int cifs_get_fattr(struct cifs_open_info_data *data, 1262 struct super_block *sb, int xid, 1263 const struct cifs_fid *fid, 1264 struct cifs_fattr *fattr, 1265 struct inode **inode, 1266 const char *full_path) 1267 { 1268 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 1269 struct cifs_open_info_data tmp_data = {}; 1270 void *smb1_backup_rsp_buf = NULL; 1271 struct TCP_Server_Info *server; 1272 struct cifs_tcon *tcon; 1273 struct tcon_link *tlink; 1274 unsigned int sbflags; 1275 int tmprc = 0; 1276 int rc = 0; 1277 1278 tlink = cifs_sb_tlink(cifs_sb); 1279 if (IS_ERR(tlink)) 1280 return PTR_ERR(tlink); 1281 tcon = tlink_tcon(tlink); 1282 server = tcon->ses->server; 1283 1284 /* 1285 * 1. Fetch file metadata if not provided (data) 1286 */ 1287 1288 if (!data) { 1289 rc = server->ops->query_path_info(xid, tcon, cifs_sb, 1290 full_path, &tmp_data); 1291 data = &tmp_data; 1292 } 1293 1294 /* 1295 * 2. Convert it to internal cifs metadata (fattr) 1296 */ 1297 1298 switch (rc) { 1299 case 0: 1300 /* 1301 * If the file is a reparse point, it is more complicated 1302 * since we have to check if its reparse tag matches a known 1303 * special file type e.g. symlink or fifo or char etc. 1304 */ 1305 if (cifs_open_data_reparse(data)) { 1306 rc = reparse_info_to_fattr(data, sb, xid, tcon, 1307 full_path, fattr); 1308 } else { 1309 cifs_open_info_to_fattr(fattr, data, sb); 1310 } 1311 if (!rc && *inode && 1312 (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)) 1313 cifs_mark_open_handles_for_deleted_file(*inode, full_path); 1314 break; 1315 case -EREMOTE: 1316 /* DFS link, no metadata available on this server */ 1317 cifs_create_junction_fattr(fattr, sb); 1318 rc = 0; 1319 break; 1320 case -EACCES: 1321 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1322 /* 1323 * perm errors, try again with backup flags if possible 1324 * 1325 * For SMB2 and later the backup intent flag 1326 * is already sent if needed on open and there 1327 * is no path based FindFirst operation to use 1328 * to retry with 1329 */ 1330 if (backup_cred(cifs_sb) && is_smb1_server(server)) { 1331 /* for easier reading */ 1332 FILE_ALL_INFO *fi; 1333 FILE_DIRECTORY_INFO *fdi; 1334 FILE_ID_FULL_DIR_INFO *si; 1335 1336 rc = cifs_backup_query_path_info(xid, tcon, sb, 1337 full_path, 1338 &smb1_backup_rsp_buf, 1339 &fi); 1340 if (rc) 1341 goto out; 1342 1343 move_cifs_info_to_smb2(&data->fi, fi); 1344 fdi = (FILE_DIRECTORY_INFO *)fi; 1345 si = (FILE_ID_FULL_DIR_INFO *)fi; 1346 1347 cifs_dir_info_to_fattr(fattr, fdi, cifs_sb); 1348 fattr->cf_uniqueid = le64_to_cpu(si->UniqueId); 1349 /* uniqueid set, skip get inum step */ 1350 goto handle_mnt_opt; 1351 } else { 1352 /* nothing we can do, bail out */ 1353 goto out; 1354 } 1355 #else 1356 goto out; 1357 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1358 break; 1359 default: 1360 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc); 1361 goto out; 1362 } 1363 1364 /* 1365 * 3. Get or update inode number (fattr->cf_uniqueid) 1366 */ 1367 1368 cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, fattr); 1369 1370 /* 1371 * 4. Tweak fattr based on mount options 1372 */ 1373 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1374 handle_mnt_opt: 1375 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1376 sbflags = cifs_sb_flags(cifs_sb); 1377 /* query for SFU type info if supported and needed */ 1378 if ((fattr->cf_cifsattrs & ATTR_SYSTEM) && 1379 (sbflags & CIFS_MOUNT_UNX_EMUL)) { 1380 tmprc = cifs_sfu_type(fattr, full_path, cifs_sb, xid); 1381 if (tmprc) 1382 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc); 1383 } 1384 1385 /* fill in 0777 bits from ACL */ 1386 if (sbflags & CIFS_MOUNT_MODE_FROM_SID) { 1387 rc = cifs_acl_to_fattr(cifs_sb, fattr, *inode, 1388 true, full_path, fid); 1389 if (rc == -EREMOTE) 1390 rc = 0; 1391 if (rc) { 1392 cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n", 1393 __func__, rc); 1394 goto out; 1395 } 1396 } else if (sbflags & CIFS_MOUNT_CIFS_ACL) { 1397 rc = cifs_acl_to_fattr(cifs_sb, fattr, *inode, 1398 false, full_path, fid); 1399 if (rc == -EREMOTE) 1400 rc = 0; 1401 if (rc) { 1402 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n", 1403 __func__, rc); 1404 goto out; 1405 } 1406 } else if (sbflags & CIFS_MOUNT_UNX_EMUL) 1407 /* fill in remaining high mode bits e.g. SUID, VTX */ 1408 cifs_sfu_mode(fattr, full_path, cifs_sb, xid); 1409 else if (!(tcon->posix_extensions)) 1410 /* clear write bits if ATTR_READONLY is set */ 1411 if (fattr->cf_cifsattrs & ATTR_READONLY) 1412 fattr->cf_mode &= ~(S_IWUGO); 1413 1414 1415 /* check for Minshall+French symlinks */ 1416 if (sbflags & CIFS_MOUNT_MF_SYMLINKS) { 1417 tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path); 1418 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc); 1419 } 1420 1421 out: 1422 cifs_buf_release(smb1_backup_rsp_buf); 1423 cifs_put_tlink(tlink); 1424 cifs_free_open_info(&tmp_data); 1425 return rc; 1426 } 1427 1428 int cifs_get_inode_info(struct inode **inode, 1429 const char *full_path, 1430 struct cifs_open_info_data *data, 1431 struct super_block *sb, int xid, 1432 const struct cifs_fid *fid) 1433 { 1434 struct cifs_fattr fattr = {}; 1435 int rc; 1436 1437 if (!data && is_inode_cache_good(*inode)) { 1438 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n"); 1439 return 0; 1440 } 1441 1442 rc = cifs_get_fattr(data, sb, xid, fid, &fattr, inode, full_path); 1443 if (rc) 1444 goto out; 1445 1446 rc = update_inode_info(sb, &fattr, inode); 1447 out: 1448 kfree(fattr.cf_symlink_target); 1449 return rc; 1450 } 1451 1452 static int smb311_posix_get_fattr(struct cifs_open_info_data *data, 1453 struct cifs_fattr *fattr, 1454 const char *full_path, 1455 struct super_block *sb, 1456 const unsigned int xid) 1457 { 1458 struct cifs_open_info_data tmp_data = {}; 1459 struct TCP_Server_Info *server; 1460 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 1461 struct cifs_tcon *tcon; 1462 struct tcon_link *tlink; 1463 int tmprc; 1464 int rc = 0; 1465 1466 tlink = cifs_sb_tlink(cifs_sb); 1467 if (IS_ERR(tlink)) 1468 return PTR_ERR(tlink); 1469 tcon = tlink_tcon(tlink); 1470 server = tcon->ses->server; 1471 1472 /* 1473 * 1. Fetch file metadata if not provided (data) 1474 */ 1475 if (!data) { 1476 rc = server->ops->query_path_info(xid, tcon, cifs_sb, 1477 full_path, &tmp_data); 1478 data = &tmp_data; 1479 } 1480 1481 /* 1482 * 2. Convert it to internal cifs metadata (fattr) 1483 */ 1484 1485 switch (rc) { 1486 case 0: 1487 if (cifs_open_data_reparse(data)) { 1488 rc = reparse_info_to_fattr(data, sb, xid, tcon, 1489 full_path, fattr); 1490 } else { 1491 smb311_posix_info_to_fattr(fattr, data, sb); 1492 } 1493 break; 1494 case -EREMOTE: 1495 /* DFS link, no metadata available on this server */ 1496 cifs_create_junction_fattr(fattr, sb); 1497 rc = 0; 1498 break; 1499 case -EACCES: 1500 /* 1501 * For SMB2 and later the backup intent flag 1502 * is already sent if needed on open and there 1503 * is no path based FindFirst operation to use 1504 * to retry with so nothing we can do, bail out 1505 */ 1506 goto out; 1507 default: 1508 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc); 1509 goto out; 1510 } 1511 1512 /* 1513 * 3. Tweak fattr based on mount options 1514 */ 1515 /* check for Minshall+French symlinks */ 1516 if (cifs_sb_flags(cifs_sb) & CIFS_MOUNT_MF_SYMLINKS) { 1517 tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path); 1518 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc); 1519 } 1520 1521 out: 1522 cifs_put_tlink(tlink); 1523 cifs_free_open_info(data); 1524 return rc; 1525 } 1526 1527 int smb311_posix_get_inode_info(struct inode **inode, 1528 const char *full_path, 1529 struct cifs_open_info_data *data, 1530 struct super_block *sb, 1531 const unsigned int xid) 1532 { 1533 struct cifs_fattr fattr = {}; 1534 int rc; 1535 1536 if (!data && is_inode_cache_good(*inode)) { 1537 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n"); 1538 return 0; 1539 } 1540 1541 rc = smb311_posix_get_fattr(data, &fattr, full_path, sb, xid); 1542 if (rc) 1543 goto out; 1544 1545 rc = update_inode_info(sb, &fattr, inode); 1546 if (!rc && fattr.cf_flags & CIFS_FATTR_DELETE_PENDING) 1547 cifs_mark_open_handles_for_deleted_file(*inode, full_path); 1548 out: 1549 kfree(fattr.cf_symlink_target); 1550 return rc; 1551 } 1552 1553 static const struct inode_operations cifs_ipc_inode_ops = { 1554 .lookup = cifs_lookup, 1555 }; 1556 1557 static int 1558 cifs_find_inode(struct inode *inode, void *opaque) 1559 { 1560 struct cifs_fattr *fattr = opaque; 1561 1562 /* [!] The compared values must be the same in struct cifs_fscache_inode_key. */ 1563 1564 /* don't match inode with different uniqueid */ 1565 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid) 1566 return 0; 1567 1568 /* use createtime like an i_generation field */ 1569 if (CIFS_I(inode)->createtime != fattr->cf_createtime) 1570 return 0; 1571 1572 /* don't match inode of different type */ 1573 if (inode_wrong_type(inode, fattr->cf_mode)) 1574 return 0; 1575 1576 /* if it's not a directory or has no dentries, then flag it */ 1577 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry)) 1578 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION; 1579 1580 return 1; 1581 } 1582 1583 static int 1584 cifs_init_inode(struct inode *inode, void *opaque) 1585 { 1586 struct cifs_fattr *fattr = opaque; 1587 1588 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid; 1589 CIFS_I(inode)->createtime = fattr->cf_createtime; 1590 return 0; 1591 } 1592 1593 /* 1594 * walk dentry list for an inode and report whether it has aliases that 1595 * are hashed. We use this to determine if a directory inode can actually 1596 * be used. 1597 */ 1598 static bool 1599 inode_has_hashed_dentries(struct inode *inode) 1600 { 1601 struct dentry *dentry; 1602 1603 spin_lock(&inode->i_lock); 1604 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) { 1605 if (!d_unhashed(dentry) || IS_ROOT(dentry)) { 1606 spin_unlock(&inode->i_lock); 1607 return true; 1608 } 1609 } 1610 spin_unlock(&inode->i_lock); 1611 return false; 1612 } 1613 1614 /* Given fattrs, get a corresponding inode */ 1615 struct inode * 1616 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr) 1617 { 1618 unsigned long hash; 1619 struct inode *inode; 1620 1621 retry_iget5_locked: 1622 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid); 1623 1624 /* hash down to 32-bits on 32-bit arch */ 1625 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid); 1626 1627 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr); 1628 if (inode) { 1629 /* was there a potentially problematic inode collision? */ 1630 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) { 1631 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION; 1632 1633 if (inode_has_hashed_dentries(inode)) { 1634 cifs_autodisable_serverino(CIFS_SB(sb)); 1635 iput(inode); 1636 fattr->cf_uniqueid = iunique(sb, ROOT_I); 1637 goto retry_iget5_locked; 1638 } 1639 } 1640 1641 /* can't fail - see cifs_find_inode() */ 1642 cifs_fattr_to_inode(inode, fattr, false); 1643 if (sb->s_flags & SB_NOATIME) 1644 inode->i_flags |= S_NOATIME | S_NOCMTIME; 1645 if (inode_state_read_once(inode) & I_NEW) { 1646 inode->i_ino = hash; 1647 cifs_fscache_get_inode_cookie(inode); 1648 unlock_new_inode(inode); 1649 } 1650 } 1651 1652 return inode; 1653 } 1654 1655 /* gets root inode */ 1656 struct inode *cifs_root_iget(struct super_block *sb) 1657 { 1658 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 1659 struct cifs_fattr fattr = {}; 1660 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 1661 struct inode *inode = NULL; 1662 unsigned int xid; 1663 char *path = NULL; 1664 int len; 1665 int rc; 1666 1667 if ((cifs_sb_flags(cifs_sb) & CIFS_MOUNT_USE_PREFIX_PATH) 1668 && cifs_sb->prepath) { 1669 len = strlen(cifs_sb->prepath); 1670 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL); 1671 if (path == NULL) 1672 return ERR_PTR(-ENOMEM); 1673 path[0] = '/'; 1674 memcpy(path+1, cifs_sb->prepath, len); 1675 } else { 1676 path = kstrdup("", GFP_KERNEL); 1677 if (path == NULL) 1678 return ERR_PTR(-ENOMEM); 1679 } 1680 1681 xid = get_xid(); 1682 if (tcon->unix_ext) { 1683 rc = cifs_get_unix_fattr(path, sb, &fattr, &inode, xid); 1684 /* some servers mistakenly claim POSIX support */ 1685 if (rc != -EOPNOTSUPP) 1686 goto iget_root; 1687 cifs_dbg(VFS, "server does not support POSIX extensions\n"); 1688 tcon->unix_ext = false; 1689 } 1690 1691 convert_delimiter(path, CIFS_DIR_SEP(cifs_sb)); 1692 if (tcon->posix_extensions) 1693 rc = smb311_posix_get_fattr(NULL, &fattr, path, sb, xid); 1694 else 1695 rc = cifs_get_fattr(NULL, sb, xid, NULL, &fattr, &inode, path); 1696 1697 iget_root: 1698 if (!rc) { 1699 if (fattr.cf_flags & CIFS_FATTR_JUNCTION) { 1700 fattr.cf_flags &= ~CIFS_FATTR_JUNCTION; 1701 cifs_autodisable_serverino(cifs_sb); 1702 } 1703 inode = cifs_iget(sb, &fattr); 1704 } 1705 1706 if (!inode) { 1707 inode = ERR_PTR(rc); 1708 goto out; 1709 } 1710 1711 if (!rc && fattr.cf_flags & CIFS_FATTR_DELETE_PENDING) 1712 cifs_mark_open_handles_for_deleted_file(inode, path); 1713 1714 if (rc && tcon->pipe) { 1715 cifs_dbg(FYI, "ipc connection - fake read inode\n"); 1716 spin_lock(&inode->i_lock); 1717 inode->i_mode |= S_IFDIR; 1718 set_nlink(inode, 2); 1719 inode->i_op = &cifs_ipc_inode_ops; 1720 inode->i_fop = &simple_dir_operations; 1721 inode->i_uid = cifs_sb->ctx->linux_uid; 1722 inode->i_gid = cifs_sb->ctx->linux_gid; 1723 spin_unlock(&inode->i_lock); 1724 } else if (rc) { 1725 iget_failed(inode); 1726 inode = ERR_PTR(rc); 1727 } 1728 1729 out: 1730 kfree(path); 1731 free_xid(xid); 1732 kfree(fattr.cf_symlink_target); 1733 return inode; 1734 } 1735 1736 int 1737 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid, 1738 const char *full_path, __u32 dosattr) 1739 { 1740 bool set_time = false; 1741 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 1742 struct TCP_Server_Info *server; 1743 FILE_BASIC_INFO info_buf; 1744 1745 if (attrs == NULL) 1746 return -EINVAL; 1747 1748 server = cifs_sb_master_tcon(cifs_sb)->ses->server; 1749 if (!server->ops->set_file_info) 1750 return -ENOSYS; 1751 1752 info_buf.Pad = 0; 1753 1754 if (attrs->ia_valid & ATTR_ATIME) { 1755 set_time = true; 1756 info_buf.LastAccessTime = 1757 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime)); 1758 } else 1759 info_buf.LastAccessTime = 0; 1760 1761 if (attrs->ia_valid & ATTR_MTIME) { 1762 set_time = true; 1763 info_buf.LastWriteTime = 1764 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime)); 1765 } else 1766 info_buf.LastWriteTime = 0; 1767 1768 /* 1769 * Samba throws this field away, but windows may actually use it. 1770 * Do not set ctime unless other time stamps are changed explicitly 1771 * (i.e. by utimes()) since we would then have a mix of client and 1772 * server times. 1773 */ 1774 if (set_time && (attrs->ia_valid & ATTR_CTIME)) { 1775 cifs_dbg(FYI, "CIFS - CTIME changed\n"); 1776 info_buf.ChangeTime = 1777 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime)); 1778 } else 1779 info_buf.ChangeTime = 0; 1780 1781 info_buf.CreationTime = 0; /* don't change */ 1782 info_buf.Attributes = cpu_to_le32(dosattr); 1783 1784 return server->ops->set_file_info(inode, full_path, &info_buf, xid); 1785 } 1786 1787 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1788 /* 1789 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit 1790 * and rename it to a random name that hopefully won't conflict with 1791 * anything else. 1792 */ 1793 int 1794 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry, 1795 const unsigned int xid) 1796 { 1797 int oplock = 0; 1798 int rc; 1799 struct cifs_fid fid; 1800 struct cifs_open_parms oparms; 1801 struct inode *inode = d_inode(dentry); 1802 struct cifsInodeInfo *cifsInode = CIFS_I(inode); 1803 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 1804 struct tcon_link *tlink; 1805 struct cifs_tcon *tcon; 1806 __u32 dosattr, origattr; 1807 FILE_BASIC_INFO *info_buf = NULL; 1808 1809 tlink = cifs_sb_tlink(cifs_sb); 1810 if (IS_ERR(tlink)) 1811 return PTR_ERR(tlink); 1812 tcon = tlink_tcon(tlink); 1813 1814 /* 1815 * We cannot rename the file if the server doesn't support 1816 * CAP_INFOLEVEL_PASSTHRU 1817 */ 1818 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) { 1819 rc = -EBUSY; 1820 goto out; 1821 } 1822 1823 oparms = (struct cifs_open_parms) { 1824 .tcon = tcon, 1825 .cifs_sb = cifs_sb, 1826 .desired_access = DELETE | FILE_WRITE_ATTRIBUTES, 1827 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR), 1828 .disposition = FILE_OPEN, 1829 .path = full_path, 1830 .fid = &fid, 1831 }; 1832 1833 rc = CIFS_open(xid, &oparms, &oplock, NULL); 1834 if (rc != 0) 1835 goto out; 1836 1837 origattr = cifsInode->cifsAttrs; 1838 if (origattr == 0) 1839 origattr |= ATTR_NORMAL; 1840 1841 dosattr = origattr & ~ATTR_READONLY; 1842 if (dosattr == 0) 1843 dosattr |= ATTR_NORMAL; 1844 dosattr |= ATTR_HIDDEN; 1845 1846 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */ 1847 if (dosattr != origattr) { 1848 info_buf = kzalloc_obj(*info_buf); 1849 if (info_buf == NULL) { 1850 rc = -ENOMEM; 1851 goto out_close; 1852 } 1853 info_buf->Attributes = cpu_to_le32(dosattr); 1854 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid, 1855 current->tgid); 1856 /* although we would like to mark the file hidden 1857 if that fails we will still try to rename it */ 1858 if (!rc) 1859 cifsInode->cifsAttrs = dosattr; 1860 else 1861 dosattr = origattr; /* since not able to change them */ 1862 } 1863 1864 /* rename the file */ 1865 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL, 1866 cifs_sb->local_nls, 1867 cifs_remap(cifs_sb)); 1868 if (rc != 0) { 1869 rc = -EBUSY; 1870 goto undo_setattr; 1871 } 1872 1873 /* try to set DELETE_ON_CLOSE */ 1874 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) { 1875 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid, 1876 current->tgid); 1877 /* 1878 * some samba versions return -ENOENT when we try to set the 1879 * file disposition here. Likely a samba bug, but work around 1880 * it for now. This means that some cifsXXX files may hang 1881 * around after they shouldn't. 1882 * 1883 * BB: remove this hack after more servers have the fix 1884 */ 1885 if (rc == -ENOENT) 1886 rc = 0; 1887 else if (rc != 0) { 1888 rc = -EBUSY; 1889 goto undo_rename; 1890 } 1891 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags); 1892 } 1893 1894 out_close: 1895 CIFSSMBClose(xid, tcon, fid.netfid); 1896 out: 1897 kfree(info_buf); 1898 cifs_put_tlink(tlink); 1899 return rc; 1900 1901 /* 1902 * reset everything back to the original state. Don't bother 1903 * dealing with errors here since we can't do anything about 1904 * them anyway. 1905 */ 1906 undo_rename: 1907 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name, 1908 cifs_sb->local_nls, cifs_remap(cifs_sb)); 1909 undo_setattr: 1910 if (dosattr != origattr) { 1911 info_buf->Attributes = cpu_to_le32(origattr); 1912 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid, 1913 current->tgid)) 1914 cifsInode->cifsAttrs = origattr; 1915 } 1916 1917 goto out_close; 1918 } 1919 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1920 1921 /* copied from fs/nfs/dir.c with small changes */ 1922 static void 1923 cifs_drop_nlink(struct inode *inode) 1924 { 1925 spin_lock(&inode->i_lock); 1926 if (inode->i_nlink > 0) 1927 drop_nlink(inode); 1928 spin_unlock(&inode->i_lock); 1929 } 1930 1931 /* 1932 * If d_inode(dentry) is null (usually meaning the cached dentry 1933 * is a negative dentry) then we would attempt a standard SMB delete, but 1934 * if that fails we can not attempt the fall back mechanisms on EACCES 1935 * but will return the EACCES to the caller. Note that the VFS does not call 1936 * unlink on negative dentries currently. 1937 */ 1938 static int __cifs_unlink(struct inode *dir, struct dentry *dentry, bool sillyrename) 1939 { 1940 int rc = 0; 1941 unsigned int xid; 1942 const char *full_path; 1943 void *page; 1944 struct inode *inode = d_inode(dentry); 1945 struct cifsInodeInfo *cifs_inode; 1946 struct super_block *sb = dir->i_sb; 1947 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 1948 struct tcon_link *tlink; 1949 struct cifs_tcon *tcon; 1950 __u32 dosattr = 0, origattr = 0; 1951 struct TCP_Server_Info *server; 1952 struct iattr *attrs = NULL; 1953 bool rehash = false; 1954 1955 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry); 1956 1957 if (unlikely(cifs_forced_shutdown(cifs_sb))) 1958 return smb_EIO(smb_eio_trace_forced_shutdown); 1959 1960 /* Unhash dentry in advance to prevent any concurrent opens */ 1961 spin_lock(&dentry->d_lock); 1962 if (!d_unhashed(dentry)) { 1963 __d_drop(dentry); 1964 rehash = true; 1965 } 1966 spin_unlock(&dentry->d_lock); 1967 1968 tlink = cifs_sb_tlink(cifs_sb); 1969 if (IS_ERR(tlink)) 1970 return PTR_ERR(tlink); 1971 tcon = tlink_tcon(tlink); 1972 server = tcon->ses->server; 1973 1974 xid = get_xid(); 1975 page = alloc_dentry_path(); 1976 1977 if (tcon->nodelete) { 1978 rc = -EACCES; 1979 goto unlink_out; 1980 } 1981 1982 /* Unlink can be called from rename so we can not take the 1983 * sb->s_vfs_rename_mutex here */ 1984 full_path = build_path_from_dentry(dentry, page); 1985 if (IS_ERR(full_path)) { 1986 rc = PTR_ERR(full_path); 1987 goto unlink_out; 1988 } 1989 1990 netfs_wait_for_outstanding_io(inode); 1991 cifs_close_deferred_file_under_dentry(tcon, dentry); 1992 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1993 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP & 1994 le64_to_cpu(tcon->fsUnixInfo.Capability))) { 1995 rc = CIFSPOSIXDelFile(xid, tcon, full_path, 1996 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls, 1997 cifs_remap(cifs_sb)); 1998 cifs_dbg(FYI, "posix del rc %d\n", rc); 1999 if ((rc == 0) || (rc == -ENOENT)) 2000 goto psx_del_no_retry; 2001 } 2002 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2003 2004 retry_std_delete: 2005 if (!server->ops->unlink) { 2006 rc = -ENOSYS; 2007 goto psx_del_no_retry; 2008 } 2009 2010 /* For SMB2+, if the file is open, we always perform a silly rename. 2011 * 2012 * We check for d_count() right after calling 2013 * cifs_close_deferred_file_under_dentry() to make sure that the 2014 * dentry's refcount gets dropped in case the file had any deferred 2015 * close. 2016 */ 2017 if (!sillyrename && server->vals->protocol_id > SMB10_PROT_ID) { 2018 spin_lock(&dentry->d_lock); 2019 if (d_count(dentry) > 1) 2020 sillyrename = true; 2021 spin_unlock(&dentry->d_lock); 2022 } 2023 2024 if (sillyrename) 2025 rc = -EBUSY; 2026 else 2027 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb, dentry); 2028 2029 psx_del_no_retry: 2030 if (!rc) { 2031 if (inode) { 2032 cifs_mark_open_handles_for_deleted_file(inode, full_path); 2033 cifs_drop_nlink(inode); 2034 } 2035 } else if (rc == -ENOENT) { 2036 if (simple_positive(dentry)) 2037 d_delete(dentry); 2038 } else if (rc == -EBUSY) { 2039 if (server->ops->rename_pending_delete) { 2040 rc = server->ops->rename_pending_delete(full_path, 2041 dentry, xid); 2042 if (rc == 0) { 2043 cifs_mark_open_handles_for_deleted_file(inode, full_path); 2044 cifs_drop_nlink(inode); 2045 } 2046 } 2047 } else if ((rc == -EACCES) && (dosattr == 0) && inode) { 2048 attrs = kzalloc_obj(*attrs); 2049 if (attrs == NULL) { 2050 rc = -ENOMEM; 2051 goto out_reval; 2052 } 2053 2054 /* try to reset dos attributes */ 2055 cifs_inode = CIFS_I(inode); 2056 origattr = cifs_inode->cifsAttrs; 2057 if (origattr == 0) 2058 origattr |= ATTR_NORMAL; 2059 dosattr = origattr & ~ATTR_READONLY; 2060 if (dosattr == 0) 2061 dosattr |= ATTR_NORMAL; 2062 dosattr |= ATTR_HIDDEN; 2063 2064 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr); 2065 if (rc != 0) 2066 goto out_reval; 2067 2068 goto retry_std_delete; 2069 } 2070 2071 /* undo the setattr if we errored out and it's needed */ 2072 if (rc != 0 && dosattr != 0) 2073 cifs_set_file_info(inode, attrs, xid, full_path, origattr); 2074 2075 out_reval: 2076 if (inode) { 2077 cifs_inode = CIFS_I(inode); 2078 cifs_inode->time = 0; /* will force revalidate to get info 2079 when needed */ 2080 inode_set_ctime_current(inode); 2081 } 2082 inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir)); 2083 cifs_inode = CIFS_I(dir); 2084 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */ 2085 unlink_out: 2086 free_dentry_path(page); 2087 kfree(attrs); 2088 free_xid(xid); 2089 cifs_put_tlink(tlink); 2090 if (rehash) 2091 d_rehash(dentry); 2092 return rc; 2093 } 2094 2095 int cifs_unlink(struct inode *dir, struct dentry *dentry) 2096 { 2097 return __cifs_unlink(dir, dentry, false); 2098 } 2099 2100 static int 2101 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode, 2102 const char *full_path, struct cifs_sb_info *cifs_sb, 2103 struct cifs_tcon *tcon, const unsigned int xid) 2104 { 2105 struct inode *inode = NULL; 2106 unsigned int sbflags; 2107 int rc = 0; 2108 2109 if (tcon->posix_extensions) { 2110 rc = smb311_posix_get_inode_info(&inode, full_path, 2111 NULL, parent->i_sb, xid); 2112 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2113 } else if (tcon->unix_ext) { 2114 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb, 2115 xid); 2116 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2117 } else { 2118 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb, 2119 xid, NULL); 2120 } 2121 2122 if (rc) 2123 return rc; 2124 2125 if (!S_ISDIR(inode->i_mode)) { 2126 /* 2127 * mkdir succeeded, but another client has managed to remove the 2128 * sucker and replace it with non-directory. Return success, 2129 * but don't leave the child in dcache. 2130 */ 2131 iput(inode); 2132 d_drop(dentry); 2133 return 0; 2134 } 2135 /* 2136 * setting nlink not necessary except in cases where we failed to get it 2137 * from the server or was set bogus. Also, since this is a brand new 2138 * inode, no need to grab the i_lock before setting the i_nlink. 2139 */ 2140 if (inode->i_nlink < 2) 2141 set_nlink(inode, 2); 2142 mode &= ~current_umask(); 2143 /* must turn on setgid bit if parent dir has it */ 2144 if (parent->i_mode & S_ISGID) 2145 mode |= S_ISGID; 2146 2147 sbflags = cifs_sb_flags(cifs_sb); 2148 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2149 if (tcon->unix_ext) { 2150 struct cifs_unix_set_info_args args = { 2151 .mode = mode, 2152 .ctime = NO_CHANGE_64, 2153 .atime = NO_CHANGE_64, 2154 .mtime = NO_CHANGE_64, 2155 .device = 0, 2156 }; 2157 if (sbflags & CIFS_MOUNT_SET_UID) { 2158 args.uid = current_fsuid(); 2159 if (parent->i_mode & S_ISGID) 2160 args.gid = parent->i_gid; 2161 else 2162 args.gid = current_fsgid(); 2163 } else { 2164 args.uid = INVALID_UID; /* no change */ 2165 args.gid = INVALID_GID; /* no change */ 2166 } 2167 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args, 2168 cifs_sb->local_nls, 2169 cifs_remap(cifs_sb)); 2170 } else { 2171 #else 2172 { 2173 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2174 struct TCP_Server_Info *server = tcon->ses->server; 2175 if (!(sbflags & CIFS_MOUNT_CIFS_ACL) && 2176 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo) 2177 server->ops->mkdir_setinfo(inode, full_path, cifs_sb, 2178 tcon, xid); 2179 if (sbflags & CIFS_MOUNT_DYNPERM) 2180 inode->i_mode = (mode | S_IFDIR); 2181 2182 if (sbflags & CIFS_MOUNT_SET_UID) { 2183 inode->i_uid = current_fsuid(); 2184 if (inode->i_mode & S_ISGID) 2185 inode->i_gid = parent->i_gid; 2186 else 2187 inode->i_gid = current_fsgid(); 2188 } 2189 } 2190 d_instantiate(dentry, inode); 2191 return 0; 2192 } 2193 2194 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2195 static int 2196 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode, 2197 const char *full_path, struct cifs_sb_info *cifs_sb, 2198 struct cifs_tcon *tcon, const unsigned int xid) 2199 { 2200 int rc = 0; 2201 u32 oplock = 0; 2202 FILE_UNIX_BASIC_INFO *info = NULL; 2203 struct inode *newinode = NULL; 2204 struct cifs_fattr fattr; 2205 2206 info = kzalloc_obj(FILE_UNIX_BASIC_INFO); 2207 if (info == NULL) { 2208 rc = -ENOMEM; 2209 goto posix_mkdir_out; 2210 } 2211 2212 mode &= ~current_umask(); 2213 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode, 2214 NULL /* netfid */, info, &oplock, full_path, 2215 cifs_sb->local_nls, cifs_remap(cifs_sb)); 2216 if (rc == -EOPNOTSUPP) 2217 goto posix_mkdir_out; 2218 else if (rc) { 2219 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc); 2220 d_drop(dentry); 2221 goto posix_mkdir_out; 2222 } 2223 2224 if (info->Type == cpu_to_le32(-1)) 2225 /* no return info, go query for it */ 2226 goto posix_mkdir_get_info; 2227 /* 2228 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if 2229 * need to set uid/gid. 2230 */ 2231 2232 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb); 2233 cifs_fill_uniqueid(inode->i_sb, &fattr); 2234 newinode = cifs_iget(inode->i_sb, &fattr); 2235 if (!newinode) 2236 goto posix_mkdir_get_info; 2237 2238 d_instantiate(dentry, newinode); 2239 2240 #ifdef CONFIG_CIFS_DEBUG2 2241 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n", 2242 dentry, dentry, newinode); 2243 2244 if (newinode->i_nlink != 2) 2245 cifs_dbg(FYI, "unexpected number of links %d\n", 2246 newinode->i_nlink); 2247 #endif 2248 2249 posix_mkdir_out: 2250 kfree(info); 2251 return rc; 2252 posix_mkdir_get_info: 2253 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon, 2254 xid); 2255 goto posix_mkdir_out; 2256 } 2257 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2258 2259 struct dentry *cifs_mkdir(struct mnt_idmap *idmap, struct inode *inode, 2260 struct dentry *direntry, umode_t mode) 2261 { 2262 int rc = 0; 2263 unsigned int xid; 2264 struct cifs_sb_info *cifs_sb; 2265 struct tcon_link *tlink; 2266 struct cifs_tcon *tcon; 2267 struct TCP_Server_Info *server; 2268 const char *full_path; 2269 void *page; 2270 2271 cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n", 2272 mode, inode); 2273 2274 cifs_sb = CIFS_SB(inode->i_sb); 2275 if (unlikely(cifs_forced_shutdown(cifs_sb))) 2276 return ERR_PTR(smb_EIO(smb_eio_trace_forced_shutdown)); 2277 tlink = cifs_sb_tlink(cifs_sb); 2278 if (IS_ERR(tlink)) 2279 return ERR_CAST(tlink); 2280 tcon = tlink_tcon(tlink); 2281 2282 xid = get_xid(); 2283 2284 page = alloc_dentry_path(); 2285 full_path = build_path_from_dentry(direntry, page); 2286 if (IS_ERR(full_path)) { 2287 rc = PTR_ERR(full_path); 2288 goto mkdir_out; 2289 } 2290 2291 server = tcon->ses->server; 2292 2293 if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) { 2294 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path, 2295 cifs_sb); 2296 d_drop(direntry); /* for time being always refresh inode info */ 2297 goto mkdir_out; 2298 } 2299 2300 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2301 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP & 2302 le64_to_cpu(tcon->fsUnixInfo.Capability))) { 2303 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb, 2304 tcon, xid); 2305 if (rc != -EOPNOTSUPP) 2306 goto mkdir_out; 2307 } 2308 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2309 2310 if (!server->ops->mkdir) { 2311 rc = -ENOSYS; 2312 goto mkdir_out; 2313 } 2314 2315 /* BB add setting the equivalent of mode via CreateX w/ACLs */ 2316 rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb); 2317 if (rc) { 2318 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc); 2319 d_drop(direntry); 2320 goto mkdir_out; 2321 } 2322 2323 /* TODO: skip this for smb2/smb3 */ 2324 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon, 2325 xid); 2326 mkdir_out: 2327 /* 2328 * Force revalidate to get parent dir info when needed since cached 2329 * attributes are invalid now. 2330 */ 2331 CIFS_I(inode)->time = 0; 2332 free_dentry_path(page); 2333 free_xid(xid); 2334 cifs_put_tlink(tlink); 2335 return ERR_PTR(rc); 2336 } 2337 2338 int cifs_rmdir(struct inode *inode, struct dentry *direntry) 2339 { 2340 int rc = 0; 2341 unsigned int xid; 2342 struct cifs_sb_info *cifs_sb; 2343 struct tcon_link *tlink; 2344 struct cifs_tcon *tcon; 2345 struct TCP_Server_Info *server; 2346 const char *full_path; 2347 void *page = alloc_dentry_path(); 2348 struct cifsInodeInfo *cifsInode; 2349 2350 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode); 2351 2352 xid = get_xid(); 2353 2354 full_path = build_path_from_dentry(direntry, page); 2355 if (IS_ERR(full_path)) { 2356 rc = PTR_ERR(full_path); 2357 goto rmdir_exit; 2358 } 2359 2360 cifs_sb = CIFS_SB(inode->i_sb); 2361 if (unlikely(cifs_forced_shutdown(cifs_sb))) { 2362 rc = smb_EIO(smb_eio_trace_forced_shutdown); 2363 goto rmdir_exit; 2364 } 2365 2366 tlink = cifs_sb_tlink(cifs_sb); 2367 if (IS_ERR(tlink)) { 2368 rc = PTR_ERR(tlink); 2369 goto rmdir_exit; 2370 } 2371 tcon = tlink_tcon(tlink); 2372 server = tcon->ses->server; 2373 2374 if (!server->ops->rmdir) { 2375 rc = -ENOSYS; 2376 cifs_put_tlink(tlink); 2377 goto rmdir_exit; 2378 } 2379 2380 if (tcon->nodelete) { 2381 rc = -EACCES; 2382 cifs_put_tlink(tlink); 2383 goto rmdir_exit; 2384 } 2385 2386 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb); 2387 cifs_put_tlink(tlink); 2388 2389 cifsInode = CIFS_I(d_inode(direntry)); 2390 2391 if (!rc) { 2392 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags); 2393 spin_lock(&d_inode(direntry)->i_lock); 2394 i_size_write(d_inode(direntry), 0); 2395 clear_nlink(d_inode(direntry)); 2396 spin_unlock(&d_inode(direntry)->i_lock); 2397 } 2398 2399 /* force revalidate to go get info when needed */ 2400 cifsInode->time = 0; 2401 2402 cifsInode = CIFS_I(inode); 2403 /* 2404 * Force revalidate to get parent dir info when needed since cached 2405 * attributes are invalid now. 2406 */ 2407 cifsInode->time = 0; 2408 2409 inode_set_ctime_current(d_inode(direntry)); 2410 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode)); 2411 2412 rmdir_exit: 2413 free_dentry_path(page); 2414 free_xid(xid); 2415 return rc; 2416 } 2417 2418 static int 2419 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry, 2420 const char *from_path, struct dentry *to_dentry, 2421 const char *to_path) 2422 { 2423 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb); 2424 struct tcon_link *tlink; 2425 struct cifs_tcon *tcon; 2426 struct TCP_Server_Info *server; 2427 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2428 struct cifs_fid fid; 2429 struct cifs_open_parms oparms; 2430 int oplock; 2431 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2432 int rc; 2433 2434 tlink = cifs_sb_tlink(cifs_sb); 2435 if (IS_ERR(tlink)) 2436 return PTR_ERR(tlink); 2437 tcon = tlink_tcon(tlink); 2438 server = tcon->ses->server; 2439 2440 if (!server->ops->rename) { 2441 rc = -ENOSYS; 2442 goto do_rename_exit; 2443 } 2444 2445 /* try path-based rename first */ 2446 rc = server->ops->rename(xid, tcon, from_dentry, 2447 from_path, to_path, cifs_sb); 2448 2449 /* 2450 * Don't bother with rename by filehandle unless file is busy and 2451 * source. Note that cross directory moves do not work with 2452 * rename by filehandle to various Windows servers. 2453 */ 2454 if (rc == 0 || rc != -EBUSY) 2455 goto do_rename_exit; 2456 2457 /* Don't fall back to using SMB on SMB 2+ mount */ 2458 if (server->vals->protocol_id != 0) 2459 goto do_rename_exit; 2460 2461 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2462 /* open-file renames don't work across directories */ 2463 if (to_dentry->d_parent != from_dentry->d_parent) 2464 goto do_rename_exit; 2465 2466 /* 2467 * CIFSSMBRenameOpenFile() uses SMB_SET_FILE_RENAME_INFORMATION 2468 * which is SMB PASSTHROUGH level. 2469 */ 2470 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) 2471 goto do_rename_exit; 2472 2473 oparms = (struct cifs_open_parms) { 2474 .tcon = tcon, 2475 .cifs_sb = cifs_sb, 2476 /* open the file to be renamed -- we need DELETE perms */ 2477 .desired_access = DELETE, 2478 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR), 2479 .disposition = FILE_OPEN, 2480 .path = from_path, 2481 .fid = &fid, 2482 }; 2483 2484 rc = CIFS_open(xid, &oparms, &oplock, NULL); 2485 if (rc == 0) { 2486 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, 2487 (const char *) to_dentry->d_name.name, 2488 cifs_sb->local_nls, cifs_remap(cifs_sb)); 2489 CIFSSMBClose(xid, tcon, fid.netfid); 2490 } 2491 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2492 do_rename_exit: 2493 if (rc == 0) 2494 d_move(from_dentry, to_dentry); 2495 cifs_put_tlink(tlink); 2496 return rc; 2497 } 2498 2499 int 2500 cifs_rename2(struct mnt_idmap *idmap, struct inode *source_dir, 2501 struct dentry *source_dentry, struct inode *target_dir, 2502 struct dentry *target_dentry, unsigned int flags) 2503 { 2504 const char *from_name, *to_name; 2505 struct TCP_Server_Info *server; 2506 void *page1, *page2; 2507 struct cifs_sb_info *cifs_sb; 2508 struct tcon_link *tlink; 2509 struct cifs_tcon *tcon; 2510 bool rehash = false; 2511 unsigned int xid; 2512 int rc, tmprc; 2513 int retry_count = 0; 2514 FILE_UNIX_BASIC_INFO *info_buf_source = NULL; 2515 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2516 FILE_UNIX_BASIC_INFO *info_buf_target; 2517 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2518 2519 if (flags & ~RENAME_NOREPLACE) 2520 return -EINVAL; 2521 2522 cifs_sb = CIFS_SB(source_dir->i_sb); 2523 if (unlikely(cifs_forced_shutdown(cifs_sb))) 2524 return smb_EIO(smb_eio_trace_forced_shutdown); 2525 2526 /* 2527 * Prevent any concurrent opens on the target by unhashing the dentry. 2528 * VFS already unhashes the target when renaming directories. 2529 */ 2530 if (d_is_positive(target_dentry) && !d_is_dir(target_dentry)) { 2531 if (!d_unhashed(target_dentry)) { 2532 d_drop(target_dentry); 2533 rehash = true; 2534 } 2535 } 2536 2537 tlink = cifs_sb_tlink(cifs_sb); 2538 if (IS_ERR(tlink)) 2539 return PTR_ERR(tlink); 2540 tcon = tlink_tcon(tlink); 2541 server = tcon->ses->server; 2542 2543 page1 = alloc_dentry_path(); 2544 page2 = alloc_dentry_path(); 2545 xid = get_xid(); 2546 2547 from_name = build_path_from_dentry(source_dentry, page1); 2548 if (IS_ERR(from_name)) { 2549 rc = PTR_ERR(from_name); 2550 goto cifs_rename_exit; 2551 } 2552 2553 to_name = build_path_from_dentry(target_dentry, page2); 2554 if (IS_ERR(to_name)) { 2555 rc = PTR_ERR(to_name); 2556 goto cifs_rename_exit; 2557 } 2558 2559 cifs_close_deferred_file_under_dentry(tcon, source_dentry); 2560 if (d_inode(target_dentry) != NULL) { 2561 netfs_wait_for_outstanding_io(d_inode(target_dentry)); 2562 cifs_close_deferred_file_under_dentry(tcon, target_dentry); 2563 } 2564 2565 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry, 2566 to_name); 2567 2568 if (rc == -EACCES) { 2569 while (retry_count < 3) { 2570 cifs_close_all_deferred_files(tcon); 2571 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry, 2572 to_name); 2573 if (rc != -EACCES) 2574 break; 2575 retry_count++; 2576 } 2577 } 2578 2579 if (!rc) 2580 rehash = false; 2581 /* 2582 * No-replace is the natural behavior for CIFS, so skip unlink hacks. 2583 */ 2584 if (flags & RENAME_NOREPLACE) 2585 goto cifs_rename_exit; 2586 2587 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2588 if (rc == -EEXIST && tcon->unix_ext) { 2589 /* 2590 * Are src and dst hardlinks of same inode? We can only tell 2591 * with unix extensions enabled. 2592 */ 2593 info_buf_source = 2594 kmalloc_objs(FILE_UNIX_BASIC_INFO, 2); 2595 if (info_buf_source == NULL) { 2596 rc = -ENOMEM; 2597 goto cifs_rename_exit; 2598 } 2599 2600 info_buf_target = info_buf_source + 1; 2601 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name, 2602 info_buf_source, 2603 cifs_sb->local_nls, 2604 cifs_remap(cifs_sb)); 2605 if (tmprc != 0) 2606 goto unlink_target; 2607 2608 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name, 2609 info_buf_target, 2610 cifs_sb->local_nls, 2611 cifs_remap(cifs_sb)); 2612 2613 if (tmprc == 0 && (info_buf_source->UniqueId == 2614 info_buf_target->UniqueId)) { 2615 /* same file, POSIX says that this is a noop */ 2616 rc = 0; 2617 goto cifs_rename_exit; 2618 } 2619 } 2620 /* 2621 * else ... BB we could add the same check for Windows by 2622 * checking the UniqueId via FILE_INTERNAL_INFO 2623 */ 2624 2625 unlink_target: 2626 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2627 if (d_really_is_positive(target_dentry)) { 2628 if (!rc) { 2629 struct inode *inode = d_inode(target_dentry); 2630 /* 2631 * Samba and ksmbd servers allow renaming a target 2632 * directory that is open, so make sure to update 2633 * ->i_nlink and then mark it as delete pending. 2634 */ 2635 if (S_ISDIR(inode->i_mode)) { 2636 drop_cached_dir_by_name(xid, tcon, to_name, cifs_sb); 2637 spin_lock(&inode->i_lock); 2638 i_size_write(inode, 0); 2639 clear_nlink(inode); 2640 spin_unlock(&inode->i_lock); 2641 set_bit(CIFS_INO_DELETE_PENDING, &CIFS_I(inode)->flags); 2642 CIFS_I(inode)->time = 0; /* force reval */ 2643 inode_set_ctime_current(inode); 2644 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode)); 2645 } 2646 } else if (rc == -EACCES || rc == -EEXIST) { 2647 /* 2648 * Rename failed, possibly due to a busy target. 2649 * Retry it by unliking the target first. 2650 */ 2651 if (d_is_dir(target_dentry)) { 2652 tmprc = cifs_rmdir(target_dir, target_dentry); 2653 } else { 2654 tmprc = __cifs_unlink(target_dir, target_dentry, 2655 server->vals->protocol_id > SMB10_PROT_ID); 2656 } 2657 if (tmprc) { 2658 /* 2659 * Some servers will return STATUS_ACCESS_DENIED 2660 * or STATUS_DIRECTORY_NOT_EMPTY when failing to 2661 * rename a non-empty directory. Make sure to 2662 * propagate the appropriate error back to 2663 * userspace. 2664 */ 2665 if (tmprc == -EEXIST || tmprc == -ENOTEMPTY) 2666 rc = tmprc; 2667 goto cifs_rename_exit; 2668 } 2669 rc = cifs_do_rename(xid, source_dentry, from_name, 2670 target_dentry, to_name); 2671 if (!rc) 2672 rehash = false; 2673 } 2674 } 2675 2676 /* force revalidate to go get info when needed */ 2677 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0; 2678 2679 cifs_rename_exit: 2680 if (rehash) 2681 d_rehash(target_dentry); 2682 kfree(info_buf_source); 2683 free_dentry_path(page2); 2684 free_dentry_path(page1); 2685 free_xid(xid); 2686 cifs_put_tlink(tlink); 2687 return rc; 2688 } 2689 2690 static bool 2691 cifs_dentry_needs_reval(struct dentry *dentry) 2692 { 2693 struct inode *inode = d_inode(dentry); 2694 struct cifsInodeInfo *cifs_i = CIFS_I(inode); 2695 struct cifs_sb_info *cifs_sb = CIFS_SB(inode); 2696 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 2697 struct cached_fid *cfid = NULL; 2698 2699 if (test_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags)) 2700 return false; 2701 if (cifs_i->time == 0) 2702 return true; 2703 2704 if (CIFS_CACHE_READ(cifs_i)) 2705 return false; 2706 2707 if (!lookupCacheEnabled) 2708 return true; 2709 2710 if (!open_cached_dir_by_dentry(tcon, dentry->d_parent, &cfid)) { 2711 if (cifs_i->time > cfid->time) { 2712 close_cached_dir(cfid); 2713 return false; 2714 } 2715 close_cached_dir(cfid); 2716 } 2717 /* 2718 * depending on inode type, check if attribute caching disabled for 2719 * files or directories 2720 */ 2721 if (S_ISDIR(inode->i_mode)) { 2722 if (!cifs_sb->ctx->acdirmax) 2723 return true; 2724 if (!time_in_range(jiffies, cifs_i->time, 2725 cifs_i->time + cifs_sb->ctx->acdirmax)) 2726 return true; 2727 } else { /* file */ 2728 if (!cifs_sb->ctx->acregmax) 2729 return true; 2730 if (!time_in_range(jiffies, cifs_i->time, 2731 cifs_i->time + cifs_sb->ctx->acregmax)) 2732 return true; 2733 } 2734 2735 /* hardlinked files w/ noserverino get "special" treatment */ 2736 if (!(cifs_sb_flags(cifs_sb) & CIFS_MOUNT_SERVER_INUM) && 2737 S_ISREG(inode->i_mode) && inode->i_nlink != 1) 2738 return true; 2739 2740 return false; 2741 } 2742 2743 /** 2744 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks 2745 * 2746 * @key: currently unused 2747 * @mode: the task state to sleep in 2748 */ 2749 static int 2750 cifs_wait_bit_killable(struct wait_bit_key *key, int mode) 2751 { 2752 schedule(); 2753 if (signal_pending_state(mode, current)) 2754 return -ERESTARTSYS; 2755 return 0; 2756 } 2757 2758 int 2759 cifs_revalidate_mapping(struct inode *inode) 2760 { 2761 struct cifsInodeInfo *cifs_inode = CIFS_I(inode); 2762 struct cifs_sb_info *cifs_sb = CIFS_SB(inode); 2763 unsigned long *flags = &cifs_inode->flags; 2764 int rc; 2765 2766 /* swapfiles are not supposed to be shared */ 2767 if (IS_SWAPFILE(inode)) 2768 return 0; 2769 2770 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable, 2771 TASK_KILLABLE|TASK_FREEZABLE_UNSAFE); 2772 if (rc) 2773 return rc; 2774 2775 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) { 2776 /* for cache=singleclient, do not invalidate */ 2777 if (cifs_sb_flags(cifs_sb) & CIFS_MOUNT_RW_CACHE) 2778 goto skip_invalidate; 2779 2780 cifs_inode->netfs.zero_point = cifs_inode->netfs.remote_i_size; 2781 rc = filemap_invalidate_inode(inode, true, 0, LLONG_MAX); 2782 if (rc) { 2783 cifs_dbg(VFS, "%s: invalidate inode %p failed with rc %d\n", 2784 __func__, inode, rc); 2785 set_bit(CIFS_INO_INVALID_MAPPING, flags); 2786 } 2787 } 2788 2789 skip_invalidate: 2790 clear_bit_unlock(CIFS_INO_LOCK, flags); 2791 smp_mb__after_atomic(); 2792 wake_up_bit(flags, CIFS_INO_LOCK); 2793 2794 return rc; 2795 } 2796 2797 int 2798 cifs_zap_mapping(struct inode *inode) 2799 { 2800 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags); 2801 return cifs_revalidate_mapping(inode); 2802 } 2803 2804 int cifs_revalidate_file_attr(struct file *filp) 2805 { 2806 int rc = 0; 2807 struct dentry *dentry = file_dentry(filp); 2808 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2809 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data; 2810 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2811 2812 if (!cifs_dentry_needs_reval(dentry)) 2813 return rc; 2814 2815 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2816 if (tlink_tcon(cfile->tlink)->unix_ext) 2817 rc = cifs_get_file_info_unix(filp); 2818 else 2819 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2820 rc = cifs_get_file_info(filp); 2821 2822 return rc; 2823 } 2824 2825 int cifs_revalidate_dentry_attr(struct dentry *dentry) 2826 { 2827 unsigned int xid; 2828 int rc = 0; 2829 struct inode *inode = d_inode(dentry); 2830 struct super_block *sb = dentry->d_sb; 2831 const char *full_path; 2832 void *page; 2833 int count = 0; 2834 2835 if (inode == NULL) 2836 return -ENOENT; 2837 2838 if (!cifs_dentry_needs_reval(dentry)) 2839 return rc; 2840 2841 xid = get_xid(); 2842 2843 page = alloc_dentry_path(); 2844 full_path = build_path_from_dentry(dentry, page); 2845 if (IS_ERR(full_path)) { 2846 rc = PTR_ERR(full_path); 2847 goto out; 2848 } 2849 2850 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n", 2851 full_path, inode, icount_read(inode), 2852 dentry, cifs_get_time(dentry), jiffies); 2853 2854 again: 2855 if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions) { 2856 rc = smb311_posix_get_inode_info(&inode, full_path, 2857 NULL, sb, xid); 2858 } else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext) { 2859 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid); 2860 } else { 2861 rc = cifs_get_inode_info(&inode, full_path, NULL, sb, 2862 xid, NULL); 2863 } 2864 if (rc == -EAGAIN && count++ < 10) 2865 goto again; 2866 out: 2867 free_dentry_path(page); 2868 free_xid(xid); 2869 2870 return rc; 2871 } 2872 2873 int cifs_revalidate_file(struct file *filp) 2874 { 2875 int rc; 2876 struct inode *inode = file_inode(filp); 2877 2878 rc = cifs_revalidate_file_attr(filp); 2879 if (rc) 2880 return rc; 2881 2882 return cifs_revalidate_mapping(inode); 2883 } 2884 2885 /* revalidate a dentry's inode attributes */ 2886 int cifs_revalidate_dentry(struct dentry *dentry) 2887 { 2888 int rc; 2889 struct inode *inode = d_inode(dentry); 2890 2891 rc = cifs_revalidate_dentry_attr(dentry); 2892 if (rc) 2893 return rc; 2894 2895 return cifs_revalidate_mapping(inode); 2896 } 2897 2898 int cifs_getattr(struct mnt_idmap *idmap, const struct path *path, 2899 struct kstat *stat, u32 request_mask, unsigned int flags) 2900 { 2901 struct cifs_sb_info *cifs_sb = CIFS_SB(path->dentry); 2902 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 2903 struct dentry *dentry = path->dentry; 2904 struct inode *inode = d_inode(dentry); 2905 unsigned int sbflags; 2906 int rc; 2907 2908 if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb)))) 2909 return smb_EIO(smb_eio_trace_forced_shutdown); 2910 2911 /* 2912 * We need to be sure that all dirty pages are written and the server 2913 * has actual ctime, mtime and file length. 2914 */ 2915 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) && 2916 !CIFS_CACHE_READ(CIFS_I(inode)) && 2917 inode->i_mapping && inode->i_mapping->nrpages != 0) { 2918 rc = filemap_fdatawait(inode->i_mapping); 2919 if (rc) { 2920 mapping_set_error(inode->i_mapping, rc); 2921 return rc; 2922 } 2923 } 2924 2925 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC) 2926 CIFS_I(inode)->time = 0; /* force revalidate */ 2927 2928 /* 2929 * If the caller doesn't require syncing, only sync if 2930 * necessary (e.g. due to earlier truncate or setattr 2931 * invalidating the cached metadata) 2932 */ 2933 if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) || 2934 (CIFS_I(inode)->time == 0)) { 2935 rc = cifs_revalidate_dentry_attr(dentry); 2936 if (rc) 2937 return rc; 2938 } 2939 2940 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat); 2941 stat->blksize = cifs_sb->ctx->bsize; 2942 stat->ino = CIFS_I(inode)->uniqueid; 2943 2944 /* old CIFS Unix Extensions doesn't return create time */ 2945 if (CIFS_I(inode)->createtime) { 2946 stat->result_mask |= STATX_BTIME; 2947 stat->btime = 2948 cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime)); 2949 } 2950 2951 stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED); 2952 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED) 2953 stat->attributes |= STATX_ATTR_COMPRESSED; 2954 if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED) 2955 stat->attributes |= STATX_ATTR_ENCRYPTED; 2956 2957 /* 2958 * If on a multiuser mount without unix extensions or cifsacl being 2959 * enabled, and the admin hasn't overridden them, set the ownership 2960 * to the fsuid/fsgid of the current process. 2961 */ 2962 sbflags = cifs_sb_flags(cifs_sb); 2963 if ((sbflags & CIFS_MOUNT_MULTIUSER) && 2964 !(sbflags & CIFS_MOUNT_CIFS_ACL) && 2965 !tcon->unix_ext) { 2966 if (!(sbflags & CIFS_MOUNT_OVERR_UID)) 2967 stat->uid = current_fsuid(); 2968 if (!(sbflags & CIFS_MOUNT_OVERR_GID)) 2969 stat->gid = current_fsgid(); 2970 } 2971 return 0; 2972 } 2973 2974 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start, 2975 u64 len) 2976 { 2977 struct cifsInodeInfo *cifs_i = CIFS_I(inode); 2978 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->netfs.inode.i_sb); 2979 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 2980 struct TCP_Server_Info *server = tcon->ses->server; 2981 struct cifsFileInfo *cfile; 2982 int rc; 2983 2984 if (unlikely(cifs_forced_shutdown(cifs_sb))) 2985 return smb_EIO(smb_eio_trace_forced_shutdown); 2986 2987 /* 2988 * We need to be sure that all dirty pages are written as they 2989 * might fill holes on the server. 2990 */ 2991 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping && 2992 inode->i_mapping->nrpages != 0) { 2993 rc = filemap_fdatawait(inode->i_mapping); 2994 if (rc) { 2995 mapping_set_error(inode->i_mapping, rc); 2996 return rc; 2997 } 2998 } 2999 3000 cfile = find_readable_file(cifs_i, false); 3001 if (cfile == NULL) 3002 return -EINVAL; 3003 3004 if (server->ops->fiemap) { 3005 rc = server->ops->fiemap(tcon, cfile, fei, start, len); 3006 cifsFileInfo_put(cfile); 3007 return rc; 3008 } 3009 3010 cifsFileInfo_put(cfile); 3011 return -EOPNOTSUPP; 3012 } 3013 3014 void cifs_setsize(struct inode *inode, loff_t offset) 3015 { 3016 spin_lock(&inode->i_lock); 3017 i_size_write(inode, offset); 3018 spin_unlock(&inode->i_lock); 3019 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode)); 3020 truncate_pagecache(inode, offset); 3021 netfs_wait_for_outstanding_io(inode); 3022 } 3023 3024 int cifs_file_set_size(const unsigned int xid, struct dentry *dentry, 3025 const char *full_path, struct cifsFileInfo *open_file, 3026 loff_t size) 3027 { 3028 struct inode *inode = d_inode(dentry); 3029 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 3030 struct cifsInodeInfo *cifsInode = CIFS_I(inode); 3031 struct tcon_link *tlink = NULL; 3032 struct cifs_tcon *tcon = NULL; 3033 struct TCP_Server_Info *server; 3034 int rc = -EINVAL; 3035 3036 /* 3037 * To avoid spurious oplock breaks from server, in the case of 3038 * inodes that we already have open, avoid doing path based 3039 * setting of file size if we can do it by handle. 3040 * This keeps our caching token (oplock) and avoids timeouts 3041 * when the local oplock break takes longer to flush 3042 * writebehind data than the SMB timeout for the SetPathInfo 3043 * request would allow 3044 */ 3045 if (open_file && (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE)) { 3046 tcon = tlink_tcon(open_file->tlink); 3047 server = tcon->ses->server; 3048 rc = server->ops->set_file_size(xid, tcon, 3049 open_file, 3050 size, false); 3051 cifs_dbg(FYI, "%s: set_file_size: rc = %d\n", __func__, rc); 3052 } else { 3053 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY); 3054 if (open_file) { 3055 tcon = tlink_tcon(open_file->tlink); 3056 server = tcon->ses->server; 3057 rc = server->ops->set_file_size(xid, tcon, 3058 open_file, 3059 size, false); 3060 cifs_dbg(FYI, "%s: set_file_size: rc = %d\n", __func__, rc); 3061 cifsFileInfo_put(open_file); 3062 } 3063 } 3064 3065 if (!rc) 3066 goto set_size_out; 3067 3068 if (tcon == NULL) { 3069 tlink = cifs_sb_tlink(cifs_sb); 3070 if (IS_ERR(tlink)) 3071 return PTR_ERR(tlink); 3072 tcon = tlink_tcon(tlink); 3073 server = tcon->ses->server; 3074 } 3075 3076 /* 3077 * Set file size by pathname rather than by handle either because no 3078 * valid, writeable file handle for it was found or because there was 3079 * an error setting it by handle. 3080 */ 3081 rc = server->ops->set_path_size(xid, tcon, full_path, size, 3082 cifs_sb, false, dentry); 3083 cifs_dbg(FYI, "%s: SetEOF by path (setattrs) rc = %d\n", __func__, rc); 3084 cifs_put_tlink(tlink); 3085 3086 set_size_out: 3087 if (rc == 0) { 3088 netfs_resize_file(&cifsInode->netfs, size, true); 3089 cifs_setsize(inode, size); 3090 /* 3091 * i_blocks is not related to (i_size / i_blksize), but instead 3092 * 512 byte (2**9) size is required for calculating num blocks. 3093 * Until we can query the server for actual allocation size, 3094 * this is best estimate we have for blocks allocated for a file 3095 * Number of blocks must be rounded up so size 1 is not 0 blocks 3096 */ 3097 inode->i_blocks = (512 - 1 + size) >> 9; 3098 } 3099 3100 return rc; 3101 } 3102 3103 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 3104 static int 3105 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs) 3106 { 3107 int rc; 3108 unsigned int xid; 3109 const char *full_path; 3110 void *page = alloc_dentry_path(); 3111 struct inode *inode = d_inode(direntry); 3112 struct cifsInodeInfo *cifsInode = CIFS_I(inode); 3113 struct cifs_sb_info *cifs_sb = CIFS_SB(inode); 3114 struct tcon_link *tlink; 3115 struct cifs_tcon *pTcon; 3116 struct cifs_unix_set_info_args *args = NULL; 3117 struct cifsFileInfo *open_file = NULL; 3118 3119 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n", 3120 direntry, attrs->ia_valid); 3121 3122 xid = get_xid(); 3123 3124 if (cifs_sb_flags(cifs_sb) & CIFS_MOUNT_NO_PERM) 3125 attrs->ia_valid |= ATTR_FORCE; 3126 3127 rc = setattr_prepare(&nop_mnt_idmap, direntry, attrs); 3128 if (rc < 0) 3129 goto out; 3130 3131 if (attrs->ia_valid & ATTR_FILE) 3132 open_file = attrs->ia_file->private_data; 3133 3134 full_path = build_path_from_dentry(direntry, page); 3135 if (IS_ERR(full_path)) { 3136 rc = PTR_ERR(full_path); 3137 goto out; 3138 } 3139 3140 /* 3141 * Attempt to flush data before changing attributes. We need to do 3142 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the 3143 * ownership or mode then we may also need to do this. Here, we take 3144 * the safe way out and just do the flush on all setattr requests. If 3145 * the flush returns error, store it to report later and continue. 3146 * 3147 * BB: This should be smarter. Why bother flushing pages that 3148 * will be truncated anyway? Also, should we error out here if 3149 * the flush returns error? 3150 */ 3151 rc = filemap_write_and_wait(inode->i_mapping); 3152 if (is_interrupt_error(rc)) { 3153 rc = -ERESTARTSYS; 3154 goto out; 3155 } 3156 3157 mapping_set_error(inode->i_mapping, rc); 3158 rc = 0; 3159 3160 if (attrs->ia_valid & ATTR_SIZE) { 3161 rc = cifs_file_set_size(xid, direntry, full_path, 3162 open_file, attrs->ia_size); 3163 if (rc != 0) 3164 goto out; 3165 /* 3166 * Avoid setting timestamps on the server for ftruncate(2) to 3167 * prevent it from disabling automatic timestamp updates as per 3168 * MS-FSA 2.1.4.17. 3169 */ 3170 attrs->ia_valid &= ~(ATTR_CTIME | ATTR_MTIME); 3171 } 3172 3173 /* skip mode change if it's just for clearing setuid/setgid */ 3174 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) 3175 attrs->ia_valid &= ~ATTR_MODE; 3176 3177 args = kmalloc_obj(*args); 3178 if (args == NULL) { 3179 rc = -ENOMEM; 3180 goto out; 3181 } 3182 3183 /* set up the struct */ 3184 if (attrs->ia_valid & ATTR_MODE) 3185 args->mode = attrs->ia_mode; 3186 else 3187 args->mode = NO_CHANGE_64; 3188 3189 if (attrs->ia_valid & ATTR_UID) 3190 args->uid = attrs->ia_uid; 3191 else 3192 args->uid = INVALID_UID; /* no change */ 3193 3194 if (attrs->ia_valid & ATTR_GID) 3195 args->gid = attrs->ia_gid; 3196 else 3197 args->gid = INVALID_GID; /* no change */ 3198 3199 if (attrs->ia_valid & ATTR_ATIME) 3200 args->atime = cifs_UnixTimeToNT(attrs->ia_atime); 3201 else 3202 args->atime = NO_CHANGE_64; 3203 3204 if (attrs->ia_valid & ATTR_MTIME) 3205 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime); 3206 else 3207 args->mtime = NO_CHANGE_64; 3208 3209 if (attrs->ia_valid & ATTR_CTIME) 3210 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime); 3211 else 3212 args->ctime = NO_CHANGE_64; 3213 3214 args->device = 0; 3215 rc = -EINVAL; 3216 if (open_file && (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE)) { 3217 pTcon = tlink_tcon(open_file->tlink); 3218 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, 3219 open_file->fid.netfid, 3220 open_file->pid); 3221 } else { 3222 open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY); 3223 if (open_file) { 3224 pTcon = tlink_tcon(open_file->tlink); 3225 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, 3226 open_file->fid.netfid, 3227 open_file->pid); 3228 cifsFileInfo_put(open_file); 3229 } 3230 } 3231 3232 if (rc) { 3233 tlink = cifs_sb_tlink(cifs_sb); 3234 if (IS_ERR(tlink)) { 3235 rc = PTR_ERR(tlink); 3236 goto out; 3237 } 3238 pTcon = tlink_tcon(tlink); 3239 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args, 3240 cifs_sb->local_nls, 3241 cifs_remap(cifs_sb)); 3242 cifs_put_tlink(tlink); 3243 } 3244 3245 if (rc) 3246 goto out; 3247 3248 if ((attrs->ia_valid & ATTR_SIZE) && 3249 attrs->ia_size != i_size_read(inode)) { 3250 truncate_setsize(inode, attrs->ia_size); 3251 netfs_resize_file(&cifsInode->netfs, attrs->ia_size, true); 3252 fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size); 3253 } 3254 3255 setattr_copy(&nop_mnt_idmap, inode, attrs); 3256 mark_inode_dirty(inode); 3257 3258 /* force revalidate when any of these times are set since some 3259 of the fs types (eg ext3, fat) do not have fine enough 3260 time granularity to match protocol, and we do not have a 3261 a way (yet) to query the server fs's time granularity (and 3262 whether it rounds times down). 3263 */ 3264 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME)) 3265 cifsInode->time = 0; 3266 out: 3267 kfree(args); 3268 free_dentry_path(page); 3269 free_xid(xid); 3270 return rc; 3271 } 3272 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 3273 3274 static int 3275 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs) 3276 { 3277 struct inode *inode = d_inode(direntry); 3278 struct cifsInodeInfo *cifsInode = CIFS_I(inode); 3279 struct cifs_sb_info *cifs_sb = CIFS_SB(inode); 3280 unsigned int sbflags = cifs_sb_flags(cifs_sb); 3281 struct cifsFileInfo *cfile = NULL; 3282 void *page = alloc_dentry_path(); 3283 __u64 mode = NO_CHANGE_64; 3284 kuid_t uid = INVALID_UID; 3285 kgid_t gid = INVALID_GID; 3286 const char *full_path; 3287 __u32 dosattr = 0; 3288 int rc = -EACCES; 3289 unsigned int xid; 3290 3291 xid = get_xid(); 3292 3293 cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n", 3294 direntry, attrs->ia_valid); 3295 3296 if (sbflags & CIFS_MOUNT_NO_PERM) 3297 attrs->ia_valid |= ATTR_FORCE; 3298 3299 rc = setattr_prepare(&nop_mnt_idmap, direntry, attrs); 3300 if (rc < 0) 3301 goto cifs_setattr_exit; 3302 3303 if (attrs->ia_valid & ATTR_FILE) 3304 cfile = attrs->ia_file->private_data; 3305 3306 full_path = build_path_from_dentry(direntry, page); 3307 if (IS_ERR(full_path)) { 3308 rc = PTR_ERR(full_path); 3309 goto cifs_setattr_exit; 3310 } 3311 3312 /* 3313 * Attempt to flush data before changing attributes. We need to do 3314 * this for ATTR_SIZE and ATTR_MTIME. If the flush of the data 3315 * returns error, store it to report later and continue. 3316 * 3317 * BB: This should be smarter. Why bother flushing pages that 3318 * will be truncated anyway? Also, should we error out here if 3319 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag? 3320 */ 3321 if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) { 3322 rc = filemap_write_and_wait(inode->i_mapping); 3323 if (is_interrupt_error(rc)) { 3324 rc = -ERESTARTSYS; 3325 goto cifs_setattr_exit; 3326 } 3327 mapping_set_error(inode->i_mapping, rc); 3328 } 3329 3330 rc = 0; 3331 3332 if (attrs->ia_valid & ATTR_MTIME) { 3333 rc = cifs_file_flush(xid, inode, cfile); 3334 if (rc) 3335 goto cifs_setattr_exit; 3336 } 3337 3338 if (attrs->ia_valid & ATTR_SIZE) { 3339 rc = cifs_file_set_size(xid, direntry, full_path, 3340 cfile, attrs->ia_size); 3341 if (rc != 0) 3342 goto cifs_setattr_exit; 3343 /* 3344 * Avoid setting timestamps on the server for ftruncate(2) to 3345 * prevent it from disabling automatic timestamp updates as per 3346 * MS-FSA 2.1.4.17. 3347 */ 3348 attrs->ia_valid &= ~(ATTR_CTIME | ATTR_MTIME); 3349 } 3350 3351 if (attrs->ia_valid & ATTR_UID) 3352 uid = attrs->ia_uid; 3353 3354 if (attrs->ia_valid & ATTR_GID) 3355 gid = attrs->ia_gid; 3356 3357 if (sbflags & (CIFS_MOUNT_CIFS_ACL | CIFS_MOUNT_MODE_FROM_SID)) { 3358 if (uid_valid(uid) || gid_valid(gid)) { 3359 mode = NO_CHANGE_64; 3360 rc = id_mode_to_cifs_acl(inode, full_path, &mode, 3361 uid, gid); 3362 if (rc) { 3363 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n", 3364 __func__, rc); 3365 goto cifs_setattr_exit; 3366 } 3367 } 3368 } else if (!(sbflags & CIFS_MOUNT_SET_UID)) { 3369 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID); 3370 } 3371 3372 /* skip mode change if it's just for clearing setuid/setgid */ 3373 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) 3374 attrs->ia_valid &= ~ATTR_MODE; 3375 3376 if (attrs->ia_valid & ATTR_MODE) { 3377 mode = attrs->ia_mode; 3378 rc = 0; 3379 if ((sbflags & (CIFS_MOUNT_CIFS_ACL | CIFS_MOUNT_MODE_FROM_SID)) || 3380 cifs_sb_master_tcon(cifs_sb)->posix_extensions) { 3381 rc = id_mode_to_cifs_acl(inode, full_path, &mode, 3382 INVALID_UID, INVALID_GID); 3383 if (rc) { 3384 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n", 3385 __func__, rc); 3386 goto cifs_setattr_exit; 3387 } 3388 3389 /* 3390 * In case of CIFS_MOUNT_CIFS_ACL, we cannot support all modes. 3391 * Pick up the actual mode bits that were set. 3392 */ 3393 if (mode != attrs->ia_mode) 3394 attrs->ia_mode = mode; 3395 } else 3396 if (((mode & S_IWUGO) == 0) && 3397 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) { 3398 3399 dosattr = cifsInode->cifsAttrs | ATTR_READONLY; 3400 3401 /* fix up mode if we're not using dynperm */ 3402 if ((sbflags & CIFS_MOUNT_DYNPERM) == 0) 3403 attrs->ia_mode = inode->i_mode & ~S_IWUGO; 3404 } else if ((mode & S_IWUGO) && 3405 (cifsInode->cifsAttrs & ATTR_READONLY)) { 3406 3407 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY; 3408 /* Attributes of 0 are ignored */ 3409 if (dosattr == 0) 3410 dosattr |= ATTR_NORMAL; 3411 3412 /* reset local inode permissions to normal */ 3413 if (!(sbflags & CIFS_MOUNT_DYNPERM)) { 3414 attrs->ia_mode &= ~(S_IALLUGO); 3415 if (S_ISDIR(inode->i_mode)) 3416 attrs->ia_mode |= 3417 cifs_sb->ctx->dir_mode; 3418 else 3419 attrs->ia_mode |= 3420 cifs_sb->ctx->file_mode; 3421 } 3422 } else if (!(sbflags & CIFS_MOUNT_DYNPERM)) { 3423 /* ignore mode change - ATTR_READONLY hasn't changed */ 3424 attrs->ia_valid &= ~ATTR_MODE; 3425 } 3426 } 3427 3428 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) || 3429 ((attrs->ia_valid & ATTR_MODE) && dosattr)) { 3430 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr); 3431 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */ 3432 3433 /* Even if error on time set, no sense failing the call if 3434 the server would set the time to a reasonable value anyway, 3435 and this check ensures that we are not being called from 3436 sys_utimes in which case we ought to fail the call back to 3437 the user when the server rejects the call */ 3438 if ((rc) && (attrs->ia_valid & 3439 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE))) 3440 rc = 0; 3441 } 3442 3443 /* do not need local check to inode_check_ok since the server does 3444 that */ 3445 if (rc) 3446 goto cifs_setattr_exit; 3447 3448 if ((attrs->ia_valid & ATTR_SIZE) && 3449 attrs->ia_size != i_size_read(inode)) { 3450 truncate_setsize(inode, attrs->ia_size); 3451 netfs_resize_file(&cifsInode->netfs, attrs->ia_size, true); 3452 fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size); 3453 } 3454 3455 setattr_copy(&nop_mnt_idmap, inode, attrs); 3456 mark_inode_dirty(inode); 3457 3458 cifs_setattr_exit: 3459 free_xid(xid); 3460 free_dentry_path(page); 3461 return rc; 3462 } 3463 3464 int 3465 cifs_setattr(struct mnt_idmap *idmap, struct dentry *direntry, 3466 struct iattr *attrs) 3467 { 3468 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb); 3469 int rc, retries = 0; 3470 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 3471 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb); 3472 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 3473 3474 if (unlikely(cifs_forced_shutdown(cifs_sb))) 3475 return smb_EIO(smb_eio_trace_forced_shutdown); 3476 /* 3477 * Avoid setting [cm]time with O_TRUNC to prevent the server from 3478 * disabling automatic timestamp updates as specified in 3479 * MS-FSA 2.1.4.17. 3480 */ 3481 if (attrs->ia_valid & ATTR_OPEN) 3482 return 0; 3483 3484 do { 3485 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 3486 if (pTcon->unix_ext) 3487 rc = cifs_setattr_unix(direntry, attrs); 3488 else 3489 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 3490 rc = cifs_setattr_nounix(direntry, attrs); 3491 retries++; 3492 } while (is_retryable_error(rc) && retries < 2); 3493 3494 /* BB: add cifs_setattr_legacy for really old servers */ 3495 return rc; 3496 } 3497