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