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