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