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