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