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