1/* 2 * fs/cifs/inode.c 3 * 4 * Copyright (C) International Business Machines Corp., 2002,2010 5 * Author(s): Steve French (sfrench@us.ibm.com) 6 * 7 * This library is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU Lesser General Public License as published 9 * by the Free Software Foundation; either version 2.1 of the License, or 10 * (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 15 * the GNU Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public License 18 * along with this library; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21#include <linux/fs.h> 22#include <linux/stat.h> 23#include <linux/slab.h> 24#include <linux/pagemap.h> 25#include <linux/freezer.h> 26#include <asm/div64.h> 27#include "cifsfs.h" 28#include "cifspdu.h" 29#include "cifsglob.h" 30#include "cifsproto.h" 31#include "cifs_debug.h" 32#include "cifs_fs_sb.h" 33#include "cifs_unicode.h" 34#include "fscache.h" 35 36 37static void cifs_set_ops(struct inode *inode) 38{ 39 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 40 41 switch (inode->i_mode & S_IFMT) { 42 case S_IFREG: 43 inode->i_op = &cifs_file_inode_ops; 44 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) { 45 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL) 46 inode->i_fop = &cifs_file_direct_nobrl_ops; 47 else 48 inode->i_fop = &cifs_file_direct_ops; 49 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) { 50 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL) 51 inode->i_fop = &cifs_file_strict_nobrl_ops; 52 else 53 inode->i_fop = &cifs_file_strict_ops; 54 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL) 55 inode->i_fop = &cifs_file_nobrl_ops; 56 else { /* not direct, send byte range locks */ 57 inode->i_fop = &cifs_file_ops; 58 } 59 60 /* check if server can support readpages */ 61 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf < 62 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE) 63 inode->i_data.a_ops = &cifs_addr_ops_smallbuf; 64 else 65 inode->i_data.a_ops = &cifs_addr_ops; 66 break; 67 case S_IFDIR: 68#ifdef CONFIG_CIFS_DFS_UPCALL 69 if (IS_AUTOMOUNT(inode)) { 70 inode->i_op = &cifs_dfs_referral_inode_operations; 71 } else { 72#else /* NO DFS support, treat as a directory */ 73 { 74#endif 75 inode->i_op = &cifs_dir_inode_ops; 76 inode->i_fop = &cifs_dir_ops; 77 } 78 break; 79 case S_IFLNK: 80 inode->i_op = &cifs_symlink_inode_ops; 81 break; 82 default: 83 init_special_inode(inode, inode->i_mode, inode->i_rdev); 84 break; 85 } 86} 87 88/* check inode attributes against fattr. If they don't match, tag the 89 * inode for cache invalidation 90 */ 91static void 92cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr) 93{ 94 struct cifsInodeInfo *cifs_i = CIFS_I(inode); 95 96 cifs_dbg(FYI, "%s: revalidating inode %llu\n", 97 __func__, cifs_i->uniqueid); 98 99 if (inode->i_state & I_NEW) { 100 cifs_dbg(FYI, "%s: inode %llu is new\n", 101 __func__, cifs_i->uniqueid); 102 return; 103 } 104 105 /* don't bother with revalidation if we have an oplock */ 106 if (CIFS_CACHE_READ(cifs_i)) { 107 cifs_dbg(FYI, "%s: inode %llu is oplocked\n", 108 __func__, cifs_i->uniqueid); 109 return; 110 } 111 112 /* revalidate if mtime or size have changed */ 113 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) && 114 cifs_i->server_eof == fattr->cf_eof) { 115 cifs_dbg(FYI, "%s: inode %llu is unchanged\n", 116 __func__, cifs_i->uniqueid); 117 return; 118 } 119 120 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n", 121 __func__, cifs_i->uniqueid); 122 set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags); 123} 124 125/* 126 * copy nlink to the inode, unless it wasn't provided. Provide 127 * sane values if we don't have an existing one and none was provided 128 */ 129static void 130cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr) 131{ 132 /* 133 * if we're in a situation where we can't trust what we 134 * got from the server (readdir, some non-unix cases) 135 * fake reasonable values 136 */ 137 if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) { 138 /* only provide fake values on a new inode */ 139 if (inode->i_state & I_NEW) { 140 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) 141 set_nlink(inode, 2); 142 else 143 set_nlink(inode, 1); 144 } 145 return; 146 } 147 148 /* we trust the server, so update it */ 149 set_nlink(inode, fattr->cf_nlink); 150} 151 152/* populate an inode with info from a cifs_fattr struct */ 153void 154cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr) 155{ 156 struct cifsInodeInfo *cifs_i = CIFS_I(inode); 157 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 158 159 cifs_revalidate_cache(inode, fattr); 160 161 spin_lock(&inode->i_lock); 162 inode->i_atime = fattr->cf_atime; 163 inode->i_mtime = fattr->cf_mtime; 164 inode->i_ctime = fattr->cf_ctime; 165 inode->i_rdev = fattr->cf_rdev; 166 cifs_nlink_fattr_to_inode(inode, fattr); 167 inode->i_uid = fattr->cf_uid; 168 inode->i_gid = fattr->cf_gid; 169 170 /* if dynperm is set, don't clobber existing mode */ 171 if (inode->i_state & I_NEW || 172 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) 173 inode->i_mode = fattr->cf_mode; 174 175 cifs_i->cifsAttrs = fattr->cf_cifsattrs; 176 177 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL) 178 cifs_i->time = 0; 179 else 180 cifs_i->time = jiffies; 181 182 if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING) 183 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags); 184 else 185 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags); 186 187 cifs_i->server_eof = fattr->cf_eof; 188 /* 189 * Can't safely change the file size here if the client is writing to 190 * it due to potential races. 191 */ 192 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) { 193 i_size_write(inode, fattr->cf_eof); 194 195 /* 196 * i_blocks is not related to (i_size / i_blksize), 197 * but instead 512 byte (2**9) size is required for 198 * calculating num blocks. 199 */ 200 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9; 201 } 202 spin_unlock(&inode->i_lock); 203 204 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL) 205 inode->i_flags |= S_AUTOMOUNT; 206 if (inode->i_state & I_NEW) 207 cifs_set_ops(inode); 208} 209 210void 211cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr) 212{ 213 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 214 215 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) 216 return; 217 218 fattr->cf_uniqueid = iunique(sb, ROOT_I); 219} 220 221/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */ 222void 223cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info, 224 struct cifs_sb_info *cifs_sb) 225{ 226 memset(fattr, 0, sizeof(*fattr)); 227 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId); 228 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes); 229 fattr->cf_eof = le64_to_cpu(info->EndOfFile); 230 231 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime); 232 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime); 233 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange); 234 fattr->cf_mode = le64_to_cpu(info->Permissions); 235 236 /* 237 * Since we set the inode type below we need to mask off 238 * to avoid strange results if bits set above. 239 */ 240 fattr->cf_mode &= ~S_IFMT; 241 switch (le32_to_cpu(info->Type)) { 242 case UNIX_FILE: 243 fattr->cf_mode |= S_IFREG; 244 fattr->cf_dtype = DT_REG; 245 break; 246 case UNIX_SYMLINK: 247 fattr->cf_mode |= S_IFLNK; 248 fattr->cf_dtype = DT_LNK; 249 break; 250 case UNIX_DIR: 251 fattr->cf_mode |= S_IFDIR; 252 fattr->cf_dtype = DT_DIR; 253 break; 254 case UNIX_CHARDEV: 255 fattr->cf_mode |= S_IFCHR; 256 fattr->cf_dtype = DT_CHR; 257 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor), 258 le64_to_cpu(info->DevMinor) & MINORMASK); 259 break; 260 case UNIX_BLOCKDEV: 261 fattr->cf_mode |= S_IFBLK; 262 fattr->cf_dtype = DT_BLK; 263 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor), 264 le64_to_cpu(info->DevMinor) & MINORMASK); 265 break; 266 case UNIX_FIFO: 267 fattr->cf_mode |= S_IFIFO; 268 fattr->cf_dtype = DT_FIFO; 269 break; 270 case UNIX_SOCKET: 271 fattr->cf_mode |= S_IFSOCK; 272 fattr->cf_dtype = DT_SOCK; 273 break; 274 default: 275 /* safest to call it a file if we do not know */ 276 fattr->cf_mode |= S_IFREG; 277 fattr->cf_dtype = DT_REG; 278 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type)); 279 break; 280 } 281 282 fattr->cf_uid = cifs_sb->mnt_uid; 283 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) { 284 u64 id = le64_to_cpu(info->Uid); 285 if (id < ((uid_t)-1)) { 286 kuid_t uid = make_kuid(&init_user_ns, id); 287 if (uid_valid(uid)) 288 fattr->cf_uid = uid; 289 } 290 } 291 292 fattr->cf_gid = cifs_sb->mnt_gid; 293 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) { 294 u64 id = le64_to_cpu(info->Gid); 295 if (id < ((gid_t)-1)) { 296 kgid_t gid = make_kgid(&init_user_ns, id); 297 if (gid_valid(gid)) 298 fattr->cf_gid = gid; 299 } 300 } 301 302 fattr->cf_nlink = le64_to_cpu(info->Nlinks); 303} 304 305/* 306 * Fill a cifs_fattr struct with fake inode info. 307 * 308 * Needed to setup cifs_fattr data for the directory which is the 309 * junction to the new submount (ie to setup the fake directory 310 * which represents a DFS referral). 311 */ 312static void 313cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb) 314{ 315 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 316 317 cifs_dbg(FYI, "creating fake fattr for DFS referral\n"); 318 319 memset(fattr, 0, sizeof(*fattr)); 320 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU; 321 fattr->cf_uid = cifs_sb->mnt_uid; 322 fattr->cf_gid = cifs_sb->mnt_gid; 323 fattr->cf_atime = CURRENT_TIME; 324 fattr->cf_ctime = CURRENT_TIME; 325 fattr->cf_mtime = CURRENT_TIME; 326 fattr->cf_nlink = 2; 327 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL; 328} 329 330static int 331cifs_get_file_info_unix(struct file *filp) 332{ 333 int rc; 334 unsigned int xid; 335 FILE_UNIX_BASIC_INFO find_data; 336 struct cifs_fattr fattr; 337 struct inode *inode = file_inode(filp); 338 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 339 struct cifsFileInfo *cfile = filp->private_data; 340 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 341 342 xid = get_xid(); 343 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data); 344 if (!rc) { 345 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb); 346 } else if (rc == -EREMOTE) { 347 cifs_create_dfs_fattr(&fattr, inode->i_sb); 348 rc = 0; 349 } 350 351 cifs_fattr_to_inode(inode, &fattr); 352 free_xid(xid); 353 return rc; 354} 355 356int cifs_get_inode_info_unix(struct inode **pinode, 357 const unsigned char *full_path, 358 struct super_block *sb, unsigned int xid) 359{ 360 int rc; 361 FILE_UNIX_BASIC_INFO find_data; 362 struct cifs_fattr fattr; 363 struct cifs_tcon *tcon; 364 struct tcon_link *tlink; 365 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 366 367 cifs_dbg(FYI, "Getting info on %s\n", full_path); 368 369 tlink = cifs_sb_tlink(cifs_sb); 370 if (IS_ERR(tlink)) 371 return PTR_ERR(tlink); 372 tcon = tlink_tcon(tlink); 373 374 /* could have done a find first instead but this returns more info */ 375 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data, 376 cifs_sb->local_nls, cifs_remap(cifs_sb)); 377 cifs_put_tlink(tlink); 378 379 if (!rc) { 380 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb); 381 } else if (rc == -EREMOTE) { 382 cifs_create_dfs_fattr(&fattr, sb); 383 rc = 0; 384 } else { 385 return rc; 386 } 387 388 /* check for Minshall+French symlinks */ 389 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) { 390 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr, 391 full_path); 392 if (tmprc) 393 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc); 394 } 395 396 if (*pinode == NULL) { 397 /* get new inode */ 398 cifs_fill_uniqueid(sb, &fattr); 399 *pinode = cifs_iget(sb, &fattr); 400 if (!*pinode) 401 rc = -ENOMEM; 402 } else { 403 /* we already have inode, update it */ 404 405 /* if uniqueid is different, return error */ 406 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM && 407 CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) { 408 rc = -ESTALE; 409 goto cgiiu_exit; 410 } 411 412 /* if filetype is different, return error */ 413 if (unlikely(((*pinode)->i_mode & S_IFMT) != 414 (fattr.cf_mode & S_IFMT))) { 415 rc = -ESTALE; 416 goto cgiiu_exit; 417 } 418 419 cifs_fattr_to_inode(*pinode, &fattr); 420 } 421 422cgiiu_exit: 423 return rc; 424} 425 426static int 427cifs_sfu_type(struct cifs_fattr *fattr, const char *path, 428 struct cifs_sb_info *cifs_sb, unsigned int xid) 429{ 430 int rc; 431 __u32 oplock; 432 struct tcon_link *tlink; 433 struct cifs_tcon *tcon; 434 struct cifs_fid fid; 435 struct cifs_open_parms oparms; 436 struct cifs_io_parms io_parms; 437 char buf[24]; 438 unsigned int bytes_read; 439 char *pbuf; 440 int buf_type = CIFS_NO_BUFFER; 441 442 pbuf = buf; 443 444 fattr->cf_mode &= ~S_IFMT; 445 446 if (fattr->cf_eof == 0) { 447 fattr->cf_mode |= S_IFIFO; 448 fattr->cf_dtype = DT_FIFO; 449 return 0; 450 } else if (fattr->cf_eof < 8) { 451 fattr->cf_mode |= S_IFREG; 452 fattr->cf_dtype = DT_REG; 453 return -EINVAL; /* EOPNOTSUPP? */ 454 } 455 456 tlink = cifs_sb_tlink(cifs_sb); 457 if (IS_ERR(tlink)) 458 return PTR_ERR(tlink); 459 tcon = tlink_tcon(tlink); 460 461 oparms.tcon = tcon; 462 oparms.cifs_sb = cifs_sb; 463 oparms.desired_access = GENERIC_READ; 464 oparms.create_options = CREATE_NOT_DIR; 465 oparms.disposition = FILE_OPEN; 466 oparms.path = path; 467 oparms.fid = &fid; 468 oparms.reconnect = false; 469 470 if (tcon->ses->server->oplocks) 471 oplock = REQ_OPLOCK; 472 else 473 oplock = 0; 474 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL); 475 if (rc) { 476 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc); 477 cifs_put_tlink(tlink); 478 return rc; 479 } 480 481 /* Read header */ 482 io_parms.netfid = fid.netfid; 483 io_parms.pid = current->tgid; 484 io_parms.tcon = tcon; 485 io_parms.offset = 0; 486 io_parms.length = 24; 487 488 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms, 489 &bytes_read, &pbuf, &buf_type); 490 if ((rc == 0) && (bytes_read >= 8)) { 491 if (memcmp("IntxBLK", pbuf, 8) == 0) { 492 cifs_dbg(FYI, "Block device\n"); 493 fattr->cf_mode |= S_IFBLK; 494 fattr->cf_dtype = DT_BLK; 495 if (bytes_read == 24) { 496 /* we have enough to decode dev num */ 497 __u64 mjr; /* major */ 498 __u64 mnr; /* minor */ 499 mjr = le64_to_cpu(*(__le64 *)(pbuf+8)); 500 mnr = le64_to_cpu(*(__le64 *)(pbuf+16)); 501 fattr->cf_rdev = MKDEV(mjr, mnr); 502 } 503 } else if (memcmp("IntxCHR", pbuf, 8) == 0) { 504 cifs_dbg(FYI, "Char device\n"); 505 fattr->cf_mode |= S_IFCHR; 506 fattr->cf_dtype = DT_CHR; 507 if (bytes_read == 24) { 508 /* we have enough to decode dev num */ 509 __u64 mjr; /* major */ 510 __u64 mnr; /* minor */ 511 mjr = le64_to_cpu(*(__le64 *)(pbuf+8)); 512 mnr = le64_to_cpu(*(__le64 *)(pbuf+16)); 513 fattr->cf_rdev = MKDEV(mjr, mnr); 514 } 515 } else if (memcmp("IntxLNK", pbuf, 7) == 0) { 516 cifs_dbg(FYI, "Symlink\n"); 517 fattr->cf_mode |= S_IFLNK; 518 fattr->cf_dtype = DT_LNK; 519 } else { 520 fattr->cf_mode |= S_IFREG; /* file? */ 521 fattr->cf_dtype = DT_REG; 522 rc = -EOPNOTSUPP; 523 } 524 } else { 525 fattr->cf_mode |= S_IFREG; /* then it is a file */ 526 fattr->cf_dtype = DT_REG; 527 rc = -EOPNOTSUPP; /* or some unknown SFU type */ 528 } 529 530 tcon->ses->server->ops->close(xid, tcon, &fid); 531 cifs_put_tlink(tlink); 532 return rc; 533} 534 535#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */ 536 537/* 538 * Fetch mode bits as provided by SFU. 539 * 540 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ? 541 */ 542static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path, 543 struct cifs_sb_info *cifs_sb, unsigned int xid) 544{ 545#ifdef CONFIG_CIFS_XATTR 546 ssize_t rc; 547 char ea_value[4]; 548 __u32 mode; 549 struct tcon_link *tlink; 550 struct cifs_tcon *tcon; 551 552 tlink = cifs_sb_tlink(cifs_sb); 553 if (IS_ERR(tlink)) 554 return PTR_ERR(tlink); 555 tcon = tlink_tcon(tlink); 556 557 if (tcon->ses->server->ops->query_all_EAs == NULL) { 558 cifs_put_tlink(tlink); 559 return -EOPNOTSUPP; 560 } 561 562 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path, 563 "SETFILEBITS", ea_value, 4 /* size of buf */, 564 cifs_sb->local_nls, 565 cifs_remap(cifs_sb)); 566 cifs_put_tlink(tlink); 567 if (rc < 0) 568 return (int)rc; 569 else if (rc > 3) { 570 mode = le32_to_cpu(*((__le32 *)ea_value)); 571 fattr->cf_mode &= ~SFBITS_MASK; 572 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n", 573 mode, fattr->cf_mode); 574 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode; 575 cifs_dbg(FYI, "special mode bits 0%o\n", mode); 576 } 577 578 return 0; 579#else 580 return -EOPNOTSUPP; 581#endif 582} 583 584/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */ 585static void 586cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info, 587 struct cifs_sb_info *cifs_sb, bool adjust_tz, 588 bool symlink) 589{ 590 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 591 592 memset(fattr, 0, sizeof(*fattr)); 593 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes); 594 if (info->DeletePending) 595 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING; 596 597 if (info->LastAccessTime) 598 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime); 599 else 600 fattr->cf_atime = CURRENT_TIME; 601 602 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime); 603 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime); 604 605 if (adjust_tz) { 606 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj; 607 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj; 608 } 609 610 fattr->cf_eof = le64_to_cpu(info->EndOfFile); 611 fattr->cf_bytes = le64_to_cpu(info->AllocationSize); 612 fattr->cf_createtime = le64_to_cpu(info->CreationTime); 613 614 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks); 615 616 if (symlink) { 617 fattr->cf_mode = S_IFLNK; 618 fattr->cf_dtype = DT_LNK; 619 } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) { 620 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode; 621 fattr->cf_dtype = DT_DIR; 622 /* 623 * Server can return wrong NumberOfLinks value for directories 624 * when Unix extensions are disabled - fake it. 625 */ 626 if (!tcon->unix_ext) 627 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK; 628 } else { 629 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode; 630 fattr->cf_dtype = DT_REG; 631 632 /* clear write bits if ATTR_READONLY is set */ 633 if (fattr->cf_cifsattrs & ATTR_READONLY) 634 fattr->cf_mode &= ~(S_IWUGO); 635 636 /* 637 * Don't accept zero nlink from non-unix servers unless 638 * delete is pending. Instead mark it as unknown. 639 */ 640 if ((fattr->cf_nlink < 1) && !tcon->unix_ext && 641 !info->DeletePending) { 642 cifs_dbg(1, "bogus file nlink value %u\n", 643 fattr->cf_nlink); 644 fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK; 645 } 646 } 647 648 fattr->cf_uid = cifs_sb->mnt_uid; 649 fattr->cf_gid = cifs_sb->mnt_gid; 650} 651 652static int 653cifs_get_file_info(struct file *filp) 654{ 655 int rc; 656 unsigned int xid; 657 FILE_ALL_INFO find_data; 658 struct cifs_fattr fattr; 659 struct inode *inode = file_inode(filp); 660 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 661 struct cifsFileInfo *cfile = filp->private_data; 662 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 663 struct TCP_Server_Info *server = tcon->ses->server; 664 665 if (!server->ops->query_file_info) 666 return -ENOSYS; 667 668 xid = get_xid(); 669 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data); 670 switch (rc) { 671 case 0: 672 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false, 673 false); 674 break; 675 case -EREMOTE: 676 cifs_create_dfs_fattr(&fattr, inode->i_sb); 677 rc = 0; 678 break; 679 case -EOPNOTSUPP: 680 case -EINVAL: 681 /* 682 * FIXME: legacy server -- fall back to path-based call? 683 * for now, just skip revalidating and mark inode for 684 * immediate reval. 685 */ 686 rc = 0; 687 CIFS_I(inode)->time = 0; 688 default: 689 goto cgfi_exit; 690 } 691 692 /* 693 * don't bother with SFU junk here -- just mark inode as needing 694 * revalidation. 695 */ 696 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid; 697 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL; 698 cifs_fattr_to_inode(inode, &fattr); 699cgfi_exit: 700 free_xid(xid); 701 return rc; 702} 703 704int 705cifs_get_inode_info(struct inode **inode, const char *full_path, 706 FILE_ALL_INFO *data, struct super_block *sb, int xid, 707 const struct cifs_fid *fid) 708{ 709 bool validinum = false; 710 __u16 srchflgs; 711 int rc = 0, tmprc = ENOSYS; 712 struct cifs_tcon *tcon; 713 struct TCP_Server_Info *server; 714 struct tcon_link *tlink; 715 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 716 char *buf = NULL; 717 bool adjust_tz = false; 718 struct cifs_fattr fattr; 719 struct cifs_search_info *srchinf = NULL; 720 bool symlink = false; 721 722 tlink = cifs_sb_tlink(cifs_sb); 723 if (IS_ERR(tlink)) 724 return PTR_ERR(tlink); 725 tcon = tlink_tcon(tlink); 726 server = tcon->ses->server; 727 728 cifs_dbg(FYI, "Getting info on %s\n", full_path); 729 730 if ((data == NULL) && (*inode != NULL)) { 731 if (CIFS_CACHE_READ(CIFS_I(*inode))) { 732 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n"); 733 goto cgii_exit; 734 } 735 } 736 737 /* if inode info is not passed, get it from server */ 738 if (data == NULL) { 739 if (!server->ops->query_path_info) { 740 rc = -ENOSYS; 741 goto cgii_exit; 742 } 743 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL); 744 if (buf == NULL) { 745 rc = -ENOMEM; 746 goto cgii_exit; 747 } 748 data = (FILE_ALL_INFO *)buf; 749 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path, 750 data, &adjust_tz, &symlink); 751 } 752 753 if (!rc) { 754 cifs_all_info_to_fattr(&fattr, data, cifs_sb, adjust_tz, 755 symlink); 756 } else if (rc == -EREMOTE) { 757 cifs_create_dfs_fattr(&fattr, sb); 758 rc = 0; 759 } else if (rc == -EACCES && backup_cred(cifs_sb)) { 760 srchinf = kzalloc(sizeof(struct cifs_search_info), 761 GFP_KERNEL); 762 if (srchinf == NULL) { 763 rc = -ENOMEM; 764 goto cgii_exit; 765 } 766 767 srchinf->endOfSearch = false; 768 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO; 769 770 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS | 771 CIFS_SEARCH_CLOSE_AT_END | 772 CIFS_SEARCH_BACKUP_SEARCH; 773 774 rc = CIFSFindFirst(xid, tcon, full_path, 775 cifs_sb, NULL, srchflgs, srchinf, false); 776 if (!rc) { 777 data = 778 (FILE_ALL_INFO *)srchinf->srch_entries_start; 779 780 cifs_dir_info_to_fattr(&fattr, 781 (FILE_DIRECTORY_INFO *)data, cifs_sb); 782 fattr.cf_uniqueid = le64_to_cpu( 783 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId); 784 validinum = true; 785 786 cifs_buf_release(srchinf->ntwrk_buf_start); 787 } 788 kfree(srchinf); 789 if (rc) 790 goto cgii_exit; 791 } else 792 goto cgii_exit; 793 794 /* 795 * If an inode wasn't passed in, then get the inode number 796 * 797 * Is an i_ino of zero legal? Can we use that to check if the server 798 * supports returning inode numbers? Are there other sanity checks we 799 * can use to ensure that the server is really filling in that field? 800 */ 801 if (*inode == NULL) { 802 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) { 803 if (validinum == false) { 804 if (server->ops->get_srv_inum) 805 tmprc = server->ops->get_srv_inum(xid, 806 tcon, cifs_sb, full_path, 807 &fattr.cf_uniqueid, data); 808 if (tmprc) { 809 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n", 810 tmprc); 811 fattr.cf_uniqueid = iunique(sb, ROOT_I); 812 cifs_autodisable_serverino(cifs_sb); 813 } 814 } 815 } else 816 fattr.cf_uniqueid = iunique(sb, ROOT_I); 817 } else 818 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid; 819 820 /* query for SFU type info if supported and needed */ 821 if (fattr.cf_cifsattrs & ATTR_SYSTEM && 822 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) { 823 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid); 824 if (tmprc) 825 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc); 826 } 827 828#ifdef CONFIG_CIFS_ACL 829 /* fill in 0777 bits from ACL */ 830 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) { 831 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid); 832 if (rc) { 833 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n", 834 __func__, rc); 835 goto cgii_exit; 836 } 837 } 838#endif /* CONFIG_CIFS_ACL */ 839 840 /* fill in remaining high mode bits e.g. SUID, VTX */ 841 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) 842 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid); 843 844 /* check for Minshall+French symlinks */ 845 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) { 846 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr, 847 full_path); 848 if (tmprc) 849 cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc); 850 } 851 852 if (!*inode) { 853 *inode = cifs_iget(sb, &fattr); 854 if (!*inode) 855 rc = -ENOMEM; 856 } else { 857 /* we already have inode, update it */ 858 859 /* if filetype is different, return error */ 860 if (unlikely(((*inode)->i_mode & S_IFMT) != 861 (fattr.cf_mode & S_IFMT))) { 862 rc = -ESTALE; 863 goto cgii_exit; 864 } 865 866 cifs_fattr_to_inode(*inode, &fattr); 867 } 868 869cgii_exit: 870 kfree(buf); 871 cifs_put_tlink(tlink); 872 return rc; 873} 874 875static const struct inode_operations cifs_ipc_inode_ops = { 876 .lookup = cifs_lookup, 877}; 878 879static int 880cifs_find_inode(struct inode *inode, void *opaque) 881{ 882 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque; 883 884 /* don't match inode with different uniqueid */ 885 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid) 886 return 0; 887 888 /* use createtime like an i_generation field */ 889 if (CIFS_I(inode)->createtime != fattr->cf_createtime) 890 return 0; 891 892 /* don't match inode of different type */ 893 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT)) 894 return 0; 895 896 /* if it's not a directory or has no dentries, then flag it */ 897 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry)) 898 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION; 899 900 return 1; 901} 902 903static int 904cifs_init_inode(struct inode *inode, void *opaque) 905{ 906 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque; 907 908 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid; 909 CIFS_I(inode)->createtime = fattr->cf_createtime; 910 return 0; 911} 912 913/* 914 * walk dentry list for an inode and report whether it has aliases that 915 * are hashed. We use this to determine if a directory inode can actually 916 * be used. 917 */ 918static bool 919inode_has_hashed_dentries(struct inode *inode) 920{ 921 struct dentry *dentry; 922 923 spin_lock(&inode->i_lock); 924 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) { 925 if (!d_unhashed(dentry) || IS_ROOT(dentry)) { 926 spin_unlock(&inode->i_lock); 927 return true; 928 } 929 } 930 spin_unlock(&inode->i_lock); 931 return false; 932} 933 934/* Given fattrs, get a corresponding inode */ 935struct inode * 936cifs_iget(struct super_block *sb, struct cifs_fattr *fattr) 937{ 938 unsigned long hash; 939 struct inode *inode; 940 941retry_iget5_locked: 942 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid); 943 944 /* hash down to 32-bits on 32-bit arch */ 945 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid); 946 947 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr); 948 if (inode) { 949 /* was there a potentially problematic inode collision? */ 950 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) { 951 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION; 952 953 if (inode_has_hashed_dentries(inode)) { 954 cifs_autodisable_serverino(CIFS_SB(sb)); 955 iput(inode); 956 fattr->cf_uniqueid = iunique(sb, ROOT_I); 957 goto retry_iget5_locked; 958 } 959 } 960 961 cifs_fattr_to_inode(inode, fattr); 962 if (sb->s_flags & MS_NOATIME) 963 inode->i_flags |= S_NOATIME | S_NOCMTIME; 964 if (inode->i_state & I_NEW) { 965 inode->i_ino = hash; 966#ifdef CONFIG_CIFS_FSCACHE 967 /* initialize per-inode cache cookie pointer */ 968 CIFS_I(inode)->fscache = NULL; 969#endif 970 unlock_new_inode(inode); 971 } 972 } 973 974 return inode; 975} 976 977/* gets root inode */ 978struct inode *cifs_root_iget(struct super_block *sb) 979{ 980 unsigned int xid; 981 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 982 struct inode *inode = NULL; 983 long rc; 984 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 985 986 xid = get_xid(); 987 if (tcon->unix_ext) { 988 rc = cifs_get_inode_info_unix(&inode, "", sb, xid); 989 /* some servers mistakenly claim POSIX support */ 990 if (rc != -EOPNOTSUPP) 991 goto iget_no_retry; 992 cifs_dbg(VFS, "server does not support POSIX extensions"); 993 tcon->unix_ext = false; 994 } 995 996 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL); 997 998iget_no_retry: 999 if (!inode) { 1000 inode = ERR_PTR(rc); 1001 goto out; 1002 } 1003 1004#ifdef CONFIG_CIFS_FSCACHE 1005 /* populate tcon->resource_id */ 1006 tcon->resource_id = CIFS_I(inode)->uniqueid; 1007#endif 1008 1009 if (rc && tcon->ipc) { 1010 cifs_dbg(FYI, "ipc connection - fake read inode\n"); 1011 spin_lock(&inode->i_lock); 1012 inode->i_mode |= S_IFDIR; 1013 set_nlink(inode, 2); 1014 inode->i_op = &cifs_ipc_inode_ops; 1015 inode->i_fop = &simple_dir_operations; 1016 inode->i_uid = cifs_sb->mnt_uid; 1017 inode->i_gid = cifs_sb->mnt_gid; 1018 spin_unlock(&inode->i_lock); 1019 } else if (rc) { 1020 iget_failed(inode); 1021 inode = ERR_PTR(rc); 1022 } 1023 1024out: 1025 /* can not call macro free_xid here since in a void func 1026 * TODO: This is no longer true 1027 */ 1028 _free_xid(xid); 1029 return inode; 1030} 1031 1032int 1033cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid, 1034 char *full_path, __u32 dosattr) 1035{ 1036 bool set_time = false; 1037 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 1038 struct TCP_Server_Info *server; 1039 FILE_BASIC_INFO info_buf; 1040 1041 if (attrs == NULL) 1042 return -EINVAL; 1043 1044 server = cifs_sb_master_tcon(cifs_sb)->ses->server; 1045 if (!server->ops->set_file_info) 1046 return -ENOSYS; 1047 1048 if (attrs->ia_valid & ATTR_ATIME) { 1049 set_time = true; 1050 info_buf.LastAccessTime = 1051 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime)); 1052 } else 1053 info_buf.LastAccessTime = 0; 1054 1055 if (attrs->ia_valid & ATTR_MTIME) { 1056 set_time = true; 1057 info_buf.LastWriteTime = 1058 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime)); 1059 } else 1060 info_buf.LastWriteTime = 0; 1061 1062 /* 1063 * Samba throws this field away, but windows may actually use it. 1064 * Do not set ctime unless other time stamps are changed explicitly 1065 * (i.e. by utimes()) since we would then have a mix of client and 1066 * server times. 1067 */ 1068 if (set_time && (attrs->ia_valid & ATTR_CTIME)) { 1069 cifs_dbg(FYI, "CIFS - CTIME changed\n"); 1070 info_buf.ChangeTime = 1071 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime)); 1072 } else 1073 info_buf.ChangeTime = 0; 1074 1075 info_buf.CreationTime = 0; /* don't change */ 1076 info_buf.Attributes = cpu_to_le32(dosattr); 1077 1078 return server->ops->set_file_info(inode, full_path, &info_buf, xid); 1079} 1080 1081/* 1082 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit 1083 * and rename it to a random name that hopefully won't conflict with 1084 * anything else. 1085 */ 1086int 1087cifs_rename_pending_delete(const char *full_path, struct dentry *dentry, 1088 const unsigned int xid) 1089{ 1090 int oplock = 0; 1091 int rc; 1092 struct cifs_fid fid; 1093 struct cifs_open_parms oparms; 1094 struct inode *inode = d_inode(dentry); 1095 struct cifsInodeInfo *cifsInode = CIFS_I(inode); 1096 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 1097 struct tcon_link *tlink; 1098 struct cifs_tcon *tcon; 1099 __u32 dosattr, origattr; 1100 FILE_BASIC_INFO *info_buf = NULL; 1101 1102 tlink = cifs_sb_tlink(cifs_sb); 1103 if (IS_ERR(tlink)) 1104 return PTR_ERR(tlink); 1105 tcon = tlink_tcon(tlink); 1106 1107 /* 1108 * We cannot rename the file if the server doesn't support 1109 * CAP_INFOLEVEL_PASSTHRU 1110 */ 1111 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) { 1112 rc = -EBUSY; 1113 goto out; 1114 } 1115 1116 oparms.tcon = tcon; 1117 oparms.cifs_sb = cifs_sb; 1118 oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES; 1119 oparms.create_options = CREATE_NOT_DIR; 1120 oparms.disposition = FILE_OPEN; 1121 oparms.path = full_path; 1122 oparms.fid = &fid; 1123 oparms.reconnect = false; 1124 1125 rc = CIFS_open(xid, &oparms, &oplock, NULL); 1126 if (rc != 0) 1127 goto out; 1128 1129 origattr = cifsInode->cifsAttrs; 1130 if (origattr == 0) 1131 origattr |= ATTR_NORMAL; 1132 1133 dosattr = origattr & ~ATTR_READONLY; 1134 if (dosattr == 0) 1135 dosattr |= ATTR_NORMAL; 1136 dosattr |= ATTR_HIDDEN; 1137 1138 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */ 1139 if (dosattr != origattr) { 1140 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL); 1141 if (info_buf == NULL) { 1142 rc = -ENOMEM; 1143 goto out_close; 1144 } 1145 info_buf->Attributes = cpu_to_le32(dosattr); 1146 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid, 1147 current->tgid); 1148 /* although we would like to mark the file hidden 1149 if that fails we will still try to rename it */ 1150 if (!rc) 1151 cifsInode->cifsAttrs = dosattr; 1152 else 1153 dosattr = origattr; /* since not able to change them */ 1154 } 1155 1156 /* rename the file */ 1157 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL, 1158 cifs_sb->local_nls, 1159 cifs_remap(cifs_sb)); 1160 if (rc != 0) { 1161 rc = -EBUSY; 1162 goto undo_setattr; 1163 } 1164 1165 /* try to set DELETE_ON_CLOSE */ 1166 if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) { 1167 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid, 1168 current->tgid); 1169 /* 1170 * some samba versions return -ENOENT when we try to set the 1171 * file disposition here. Likely a samba bug, but work around 1172 * it for now. This means that some cifsXXX files may hang 1173 * around after they shouldn't. 1174 * 1175 * BB: remove this hack after more servers have the fix 1176 */ 1177 if (rc == -ENOENT) 1178 rc = 0; 1179 else if (rc != 0) { 1180 rc = -EBUSY; 1181 goto undo_rename; 1182 } 1183 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags); 1184 } 1185 1186out_close: 1187 CIFSSMBClose(xid, tcon, fid.netfid); 1188out: 1189 kfree(info_buf); 1190 cifs_put_tlink(tlink); 1191 return rc; 1192 1193 /* 1194 * reset everything back to the original state. Don't bother 1195 * dealing with errors here since we can't do anything about 1196 * them anyway. 1197 */ 1198undo_rename: 1199 CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name, 1200 cifs_sb->local_nls, cifs_remap(cifs_sb)); 1201undo_setattr: 1202 if (dosattr != origattr) { 1203 info_buf->Attributes = cpu_to_le32(origattr); 1204 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid, 1205 current->tgid)) 1206 cifsInode->cifsAttrs = origattr; 1207 } 1208 1209 goto out_close; 1210} 1211 1212/* copied from fs/nfs/dir.c with small changes */ 1213static void 1214cifs_drop_nlink(struct inode *inode) 1215{ 1216 spin_lock(&inode->i_lock); 1217 if (inode->i_nlink > 0) 1218 drop_nlink(inode); 1219 spin_unlock(&inode->i_lock); 1220} 1221 1222/* 1223 * If d_inode(dentry) is null (usually meaning the cached dentry 1224 * is a negative dentry) then we would attempt a standard SMB delete, but 1225 * if that fails we can not attempt the fall back mechanisms on EACCESS 1226 * but will return the EACCESS to the caller. Note that the VFS does not call 1227 * unlink on negative dentries currently. 1228 */ 1229int cifs_unlink(struct inode *dir, struct dentry *dentry) 1230{ 1231 int rc = 0; 1232 unsigned int xid; 1233 char *full_path = NULL; 1234 struct inode *inode = d_inode(dentry); 1235 struct cifsInodeInfo *cifs_inode; 1236 struct super_block *sb = dir->i_sb; 1237 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 1238 struct tcon_link *tlink; 1239 struct cifs_tcon *tcon; 1240 struct TCP_Server_Info *server; 1241 struct iattr *attrs = NULL; 1242 __u32 dosattr = 0, origattr = 0; 1243 1244 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry); 1245 1246 tlink = cifs_sb_tlink(cifs_sb); 1247 if (IS_ERR(tlink)) 1248 return PTR_ERR(tlink); 1249 tcon = tlink_tcon(tlink); 1250 server = tcon->ses->server; 1251 1252 xid = get_xid(); 1253 1254 /* Unlink can be called from rename so we can not take the 1255 * sb->s_vfs_rename_mutex here */ 1256 full_path = build_path_from_dentry(dentry); 1257 if (full_path == NULL) { 1258 rc = -ENOMEM; 1259 goto unlink_out; 1260 } 1261 1262 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP & 1263 le64_to_cpu(tcon->fsUnixInfo.Capability))) { 1264 rc = CIFSPOSIXDelFile(xid, tcon, full_path, 1265 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls, 1266 cifs_remap(cifs_sb)); 1267 cifs_dbg(FYI, "posix del rc %d\n", rc); 1268 if ((rc == 0) || (rc == -ENOENT)) 1269 goto psx_del_no_retry; 1270 } 1271 1272retry_std_delete: 1273 if (!server->ops->unlink) { 1274 rc = -ENOSYS; 1275 goto psx_del_no_retry; 1276 } 1277 1278 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb); 1279 1280psx_del_no_retry: 1281 if (!rc) { 1282 if (inode) 1283 cifs_drop_nlink(inode); 1284 } else if (rc == -ENOENT) { 1285 d_drop(dentry); 1286 } else if (rc == -EBUSY) { 1287 if (server->ops->rename_pending_delete) { 1288 rc = server->ops->rename_pending_delete(full_path, 1289 dentry, xid); 1290 if (rc == 0) 1291 cifs_drop_nlink(inode); 1292 } 1293 } else if ((rc == -EACCES) && (dosattr == 0) && inode) { 1294 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL); 1295 if (attrs == NULL) { 1296 rc = -ENOMEM; 1297 goto out_reval; 1298 } 1299 1300 /* try to reset dos attributes */ 1301 cifs_inode = CIFS_I(inode); 1302 origattr = cifs_inode->cifsAttrs; 1303 if (origattr == 0) 1304 origattr |= ATTR_NORMAL; 1305 dosattr = origattr & ~ATTR_READONLY; 1306 if (dosattr == 0) 1307 dosattr |= ATTR_NORMAL; 1308 dosattr |= ATTR_HIDDEN; 1309 1310 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr); 1311 if (rc != 0) 1312 goto out_reval; 1313 1314 goto retry_std_delete; 1315 } 1316 1317 /* undo the setattr if we errored out and it's needed */ 1318 if (rc != 0 && dosattr != 0) 1319 cifs_set_file_info(inode, attrs, xid, full_path, origattr); 1320 1321out_reval: 1322 if (inode) { 1323 cifs_inode = CIFS_I(inode); 1324 cifs_inode->time = 0; /* will force revalidate to get info 1325 when needed */ 1326 inode->i_ctime = current_fs_time(sb); 1327 } 1328 dir->i_ctime = dir->i_mtime = current_fs_time(sb); 1329 cifs_inode = CIFS_I(dir); 1330 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */ 1331unlink_out: 1332 kfree(full_path); 1333 kfree(attrs); 1334 free_xid(xid); 1335 cifs_put_tlink(tlink); 1336 return rc; 1337} 1338 1339static int 1340cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode, 1341 const char *full_path, struct cifs_sb_info *cifs_sb, 1342 struct cifs_tcon *tcon, const unsigned int xid) 1343{ 1344 int rc = 0; 1345 struct inode *inode = NULL; 1346 1347 if (tcon->unix_ext) 1348 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb, 1349 xid); 1350 else 1351 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb, 1352 xid, NULL); 1353 1354 if (rc) 1355 return rc; 1356 1357 /* 1358 * setting nlink not necessary except in cases where we failed to get it 1359 * from the server or was set bogus. Also, since this is a brand new 1360 * inode, no need to grab the i_lock before setting the i_nlink. 1361 */ 1362 if (inode->i_nlink < 2) 1363 set_nlink(inode, 2); 1364 mode &= ~current_umask(); 1365 /* must turn on setgid bit if parent dir has it */ 1366 if (parent->i_mode & S_ISGID) 1367 mode |= S_ISGID; 1368 1369 if (tcon->unix_ext) { 1370 struct cifs_unix_set_info_args args = { 1371 .mode = mode, 1372 .ctime = NO_CHANGE_64, 1373 .atime = NO_CHANGE_64, 1374 .mtime = NO_CHANGE_64, 1375 .device = 0, 1376 }; 1377 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) { 1378 args.uid = current_fsuid(); 1379 if (parent->i_mode & S_ISGID) 1380 args.gid = parent->i_gid; 1381 else 1382 args.gid = current_fsgid(); 1383 } else { 1384 args.uid = INVALID_UID; /* no change */ 1385 args.gid = INVALID_GID; /* no change */ 1386 } 1387 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args, 1388 cifs_sb->local_nls, 1389 cifs_remap(cifs_sb)); 1390 } else { 1391 struct TCP_Server_Info *server = tcon->ses->server; 1392 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) && 1393 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo) 1394 server->ops->mkdir_setinfo(inode, full_path, cifs_sb, 1395 tcon, xid); 1396 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) 1397 inode->i_mode = (mode | S_IFDIR); 1398 1399 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) { 1400 inode->i_uid = current_fsuid(); 1401 if (inode->i_mode & S_ISGID) 1402 inode->i_gid = parent->i_gid; 1403 else 1404 inode->i_gid = current_fsgid(); 1405 } 1406 } 1407 d_instantiate(dentry, inode); 1408 return rc; 1409} 1410 1411static int 1412cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode, 1413 const char *full_path, struct cifs_sb_info *cifs_sb, 1414 struct cifs_tcon *tcon, const unsigned int xid) 1415{ 1416 int rc = 0; 1417 u32 oplock = 0; 1418 FILE_UNIX_BASIC_INFO *info = NULL; 1419 struct inode *newinode = NULL; 1420 struct cifs_fattr fattr; 1421 1422 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL); 1423 if (info == NULL) { 1424 rc = -ENOMEM; 1425 goto posix_mkdir_out; 1426 } 1427 1428 mode &= ~current_umask(); 1429 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode, 1430 NULL /* netfid */, info, &oplock, full_path, 1431 cifs_sb->local_nls, cifs_remap(cifs_sb)); 1432 if (rc == -EOPNOTSUPP) 1433 goto posix_mkdir_out; 1434 else if (rc) { 1435 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc); 1436 d_drop(dentry); 1437 goto posix_mkdir_out; 1438 } 1439 1440 if (info->Type == cpu_to_le32(-1)) 1441 /* no return info, go query for it */ 1442 goto posix_mkdir_get_info; 1443 /* 1444 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if 1445 * need to set uid/gid. 1446 */ 1447 1448 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb); 1449 cifs_fill_uniqueid(inode->i_sb, &fattr); 1450 newinode = cifs_iget(inode->i_sb, &fattr); 1451 if (!newinode) 1452 goto posix_mkdir_get_info; 1453 1454 d_instantiate(dentry, newinode); 1455 1456#ifdef CONFIG_CIFS_DEBUG2 1457 cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n", 1458 dentry, dentry, newinode); 1459 1460 if (newinode->i_nlink != 2) 1461 cifs_dbg(FYI, "unexpected number of links %d\n", 1462 newinode->i_nlink); 1463#endif 1464 1465posix_mkdir_out: 1466 kfree(info); 1467 return rc; 1468posix_mkdir_get_info: 1469 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon, 1470 xid); 1471 goto posix_mkdir_out; 1472} 1473 1474int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode) 1475{ 1476 int rc = 0; 1477 unsigned int xid; 1478 struct cifs_sb_info *cifs_sb; 1479 struct tcon_link *tlink; 1480 struct cifs_tcon *tcon; 1481 struct TCP_Server_Info *server; 1482 char *full_path; 1483 1484 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n", 1485 mode, inode); 1486 1487 cifs_sb = CIFS_SB(inode->i_sb); 1488 tlink = cifs_sb_tlink(cifs_sb); 1489 if (IS_ERR(tlink)) 1490 return PTR_ERR(tlink); 1491 tcon = tlink_tcon(tlink); 1492 1493 xid = get_xid(); 1494 1495 full_path = build_path_from_dentry(direntry); 1496 if (full_path == NULL) { 1497 rc = -ENOMEM; 1498 goto mkdir_out; 1499 } 1500 1501 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP & 1502 le64_to_cpu(tcon->fsUnixInfo.Capability))) { 1503 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb, 1504 tcon, xid); 1505 if (rc != -EOPNOTSUPP) 1506 goto mkdir_out; 1507 } 1508 1509 server = tcon->ses->server; 1510 1511 if (!server->ops->mkdir) { 1512 rc = -ENOSYS; 1513 goto mkdir_out; 1514 } 1515 1516 /* BB add setting the equivalent of mode via CreateX w/ACLs */ 1517 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb); 1518 if (rc) { 1519 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc); 1520 d_drop(direntry); 1521 goto mkdir_out; 1522 } 1523 1524 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon, 1525 xid); 1526mkdir_out: 1527 /* 1528 * Force revalidate to get parent dir info when needed since cached 1529 * attributes are invalid now. 1530 */ 1531 CIFS_I(inode)->time = 0; 1532 kfree(full_path); 1533 free_xid(xid); 1534 cifs_put_tlink(tlink); 1535 return rc; 1536} 1537 1538int cifs_rmdir(struct inode *inode, struct dentry *direntry) 1539{ 1540 int rc = 0; 1541 unsigned int xid; 1542 struct cifs_sb_info *cifs_sb; 1543 struct tcon_link *tlink; 1544 struct cifs_tcon *tcon; 1545 struct TCP_Server_Info *server; 1546 char *full_path = NULL; 1547 struct cifsInodeInfo *cifsInode; 1548 1549 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode); 1550 1551 xid = get_xid(); 1552 1553 full_path = build_path_from_dentry(direntry); 1554 if (full_path == NULL) { 1555 rc = -ENOMEM; 1556 goto rmdir_exit; 1557 } 1558 1559 cifs_sb = CIFS_SB(inode->i_sb); 1560 tlink = cifs_sb_tlink(cifs_sb); 1561 if (IS_ERR(tlink)) { 1562 rc = PTR_ERR(tlink); 1563 goto rmdir_exit; 1564 } 1565 tcon = tlink_tcon(tlink); 1566 server = tcon->ses->server; 1567 1568 if (!server->ops->rmdir) { 1569 rc = -ENOSYS; 1570 cifs_put_tlink(tlink); 1571 goto rmdir_exit; 1572 } 1573 1574 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb); 1575 cifs_put_tlink(tlink); 1576 1577 if (!rc) { 1578 spin_lock(&d_inode(direntry)->i_lock); 1579 i_size_write(d_inode(direntry), 0); 1580 clear_nlink(d_inode(direntry)); 1581 spin_unlock(&d_inode(direntry)->i_lock); 1582 } 1583 1584 cifsInode = CIFS_I(d_inode(direntry)); 1585 /* force revalidate to go get info when needed */ 1586 cifsInode->time = 0; 1587 1588 cifsInode = CIFS_I(inode); 1589 /* 1590 * Force revalidate to get parent dir info when needed since cached 1591 * attributes are invalid now. 1592 */ 1593 cifsInode->time = 0; 1594 1595 d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime = 1596 current_fs_time(inode->i_sb); 1597 1598rmdir_exit: 1599 kfree(full_path); 1600 free_xid(xid); 1601 return rc; 1602} 1603 1604static int 1605cifs_do_rename(const unsigned int xid, struct dentry *from_dentry, 1606 const char *from_path, struct dentry *to_dentry, 1607 const char *to_path) 1608{ 1609 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb); 1610 struct tcon_link *tlink; 1611 struct cifs_tcon *tcon; 1612 struct TCP_Server_Info *server; 1613 struct cifs_fid fid; 1614 struct cifs_open_parms oparms; 1615 int oplock, rc; 1616 1617 tlink = cifs_sb_tlink(cifs_sb); 1618 if (IS_ERR(tlink)) 1619 return PTR_ERR(tlink); 1620 tcon = tlink_tcon(tlink); 1621 server = tcon->ses->server; 1622 1623 if (!server->ops->rename) 1624 return -ENOSYS; 1625 1626 /* try path-based rename first */ 1627 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb); 1628 1629 /* 1630 * Don't bother with rename by filehandle unless file is busy and 1631 * source. Note that cross directory moves do not work with 1632 * rename by filehandle to various Windows servers. 1633 */ 1634 if (rc == 0 || rc != -EBUSY) 1635 goto do_rename_exit; 1636 1637 /* open-file renames don't work across directories */ 1638 if (to_dentry->d_parent != from_dentry->d_parent) 1639 goto do_rename_exit; 1640 1641 oparms.tcon = tcon; 1642 oparms.cifs_sb = cifs_sb; 1643 /* open the file to be renamed -- we need DELETE perms */ 1644 oparms.desired_access = DELETE; 1645 oparms.create_options = CREATE_NOT_DIR; 1646 oparms.disposition = FILE_OPEN; 1647 oparms.path = from_path; 1648 oparms.fid = &fid; 1649 oparms.reconnect = false; 1650 1651 rc = CIFS_open(xid, &oparms, &oplock, NULL); 1652 if (rc == 0) { 1653 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, 1654 (const char *) to_dentry->d_name.name, 1655 cifs_sb->local_nls, cifs_remap(cifs_sb)); 1656 CIFSSMBClose(xid, tcon, fid.netfid); 1657 } 1658do_rename_exit: 1659 cifs_put_tlink(tlink); 1660 return rc; 1661} 1662 1663int 1664cifs_rename2(struct inode *source_dir, struct dentry *source_dentry, 1665 struct inode *target_dir, struct dentry *target_dentry, 1666 unsigned int flags) 1667{ 1668 char *from_name = NULL; 1669 char *to_name = NULL; 1670 struct cifs_sb_info *cifs_sb; 1671 struct tcon_link *tlink; 1672 struct cifs_tcon *tcon; 1673 FILE_UNIX_BASIC_INFO *info_buf_source = NULL; 1674 FILE_UNIX_BASIC_INFO *info_buf_target; 1675 unsigned int xid; 1676 int rc, tmprc; 1677 1678 if (flags & ~RENAME_NOREPLACE) 1679 return -EINVAL; 1680 1681 cifs_sb = CIFS_SB(source_dir->i_sb); 1682 tlink = cifs_sb_tlink(cifs_sb); 1683 if (IS_ERR(tlink)) 1684 return PTR_ERR(tlink); 1685 tcon = tlink_tcon(tlink); 1686 1687 xid = get_xid(); 1688 1689 /* 1690 * we already have the rename sem so we do not need to 1691 * grab it again here to protect the path integrity 1692 */ 1693 from_name = build_path_from_dentry(source_dentry); 1694 if (from_name == NULL) { 1695 rc = -ENOMEM; 1696 goto cifs_rename_exit; 1697 } 1698 1699 to_name = build_path_from_dentry(target_dentry); 1700 if (to_name == NULL) { 1701 rc = -ENOMEM; 1702 goto cifs_rename_exit; 1703 } 1704 1705 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry, 1706 to_name); 1707 1708 /* 1709 * No-replace is the natural behavior for CIFS, so skip unlink hacks. 1710 */ 1711 if (flags & RENAME_NOREPLACE) 1712 goto cifs_rename_exit; 1713 1714 if (rc == -EEXIST && tcon->unix_ext) { 1715 /* 1716 * Are src and dst hardlinks of same inode? We can only tell 1717 * with unix extensions enabled. 1718 */ 1719 info_buf_source = 1720 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO), 1721 GFP_KERNEL); 1722 if (info_buf_source == NULL) { 1723 rc = -ENOMEM; 1724 goto cifs_rename_exit; 1725 } 1726 1727 info_buf_target = info_buf_source + 1; 1728 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name, 1729 info_buf_source, 1730 cifs_sb->local_nls, 1731 cifs_remap(cifs_sb)); 1732 if (tmprc != 0) 1733 goto unlink_target; 1734 1735 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name, 1736 info_buf_target, 1737 cifs_sb->local_nls, 1738 cifs_remap(cifs_sb)); 1739 1740 if (tmprc == 0 && (info_buf_source->UniqueId == 1741 info_buf_target->UniqueId)) { 1742 /* same file, POSIX says that this is a noop */ 1743 rc = 0; 1744 goto cifs_rename_exit; 1745 } 1746 } 1747 /* 1748 * else ... BB we could add the same check for Windows by 1749 * checking the UniqueId via FILE_INTERNAL_INFO 1750 */ 1751 1752unlink_target: 1753 /* Try unlinking the target dentry if it's not negative */ 1754 if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) { 1755 if (d_is_dir(target_dentry)) 1756 tmprc = cifs_rmdir(target_dir, target_dentry); 1757 else 1758 tmprc = cifs_unlink(target_dir, target_dentry); 1759 if (tmprc) 1760 goto cifs_rename_exit; 1761 rc = cifs_do_rename(xid, source_dentry, from_name, 1762 target_dentry, to_name); 1763 } 1764 1765 /* force revalidate to go get info when needed */ 1766 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0; 1767 1768 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime = 1769 target_dir->i_mtime = current_fs_time(source_dir->i_sb); 1770 1771cifs_rename_exit: 1772 kfree(info_buf_source); 1773 kfree(from_name); 1774 kfree(to_name); 1775 free_xid(xid); 1776 cifs_put_tlink(tlink); 1777 return rc; 1778} 1779 1780static bool 1781cifs_inode_needs_reval(struct inode *inode) 1782{ 1783 struct cifsInodeInfo *cifs_i = CIFS_I(inode); 1784 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 1785 1786 if (CIFS_CACHE_READ(cifs_i)) 1787 return false; 1788 1789 if (!lookupCacheEnabled) 1790 return true; 1791 1792 if (cifs_i->time == 0) 1793 return true; 1794 1795 if (!cifs_sb->actimeo) 1796 return true; 1797 1798 if (!time_in_range(jiffies, cifs_i->time, 1799 cifs_i->time + cifs_sb->actimeo)) 1800 return true; 1801 1802 /* hardlinked files w/ noserverino get "special" treatment */ 1803 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) && 1804 S_ISREG(inode->i_mode) && inode->i_nlink != 1) 1805 return true; 1806 1807 return false; 1808} 1809 1810/* 1811 * Zap the cache. Called when invalid_mapping flag is set. 1812 */ 1813int 1814cifs_invalidate_mapping(struct inode *inode) 1815{ 1816 int rc = 0; 1817 1818 if (inode->i_mapping && inode->i_mapping->nrpages != 0) { 1819 rc = invalidate_inode_pages2(inode->i_mapping); 1820 if (rc) 1821 cifs_dbg(VFS, "%s: could not invalidate inode %p\n", 1822 __func__, inode); 1823 } 1824 1825 cifs_fscache_reset_inode_cookie(inode); 1826 return rc; 1827} 1828 1829/** 1830 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks 1831 * @word: long word containing the bit lock 1832 */ 1833static int 1834cifs_wait_bit_killable(struct wait_bit_key *key) 1835{ 1836 if (fatal_signal_pending(current)) 1837 return -ERESTARTSYS; 1838 freezable_schedule_unsafe(); 1839 return 0; 1840} 1841 1842int 1843cifs_revalidate_mapping(struct inode *inode) 1844{ 1845 int rc; 1846 unsigned long *flags = &CIFS_I(inode)->flags; 1847 1848 rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable, 1849 TASK_KILLABLE); 1850 if (rc) 1851 return rc; 1852 1853 if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) { 1854 rc = cifs_invalidate_mapping(inode); 1855 if (rc) 1856 set_bit(CIFS_INO_INVALID_MAPPING, flags); 1857 } 1858 1859 clear_bit_unlock(CIFS_INO_LOCK, flags); 1860 smp_mb__after_atomic(); 1861 wake_up_bit(flags, CIFS_INO_LOCK); 1862 1863 return rc; 1864} 1865 1866int 1867cifs_zap_mapping(struct inode *inode) 1868{ 1869 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags); 1870 return cifs_revalidate_mapping(inode); 1871} 1872 1873int cifs_revalidate_file_attr(struct file *filp) 1874{ 1875 int rc = 0; 1876 struct inode *inode = file_inode(filp); 1877 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data; 1878 1879 if (!cifs_inode_needs_reval(inode)) 1880 return rc; 1881 1882 if (tlink_tcon(cfile->tlink)->unix_ext) 1883 rc = cifs_get_file_info_unix(filp); 1884 else 1885 rc = cifs_get_file_info(filp); 1886 1887 return rc; 1888} 1889 1890int cifs_revalidate_dentry_attr(struct dentry *dentry) 1891{ 1892 unsigned int xid; 1893 int rc = 0; 1894 struct inode *inode = d_inode(dentry); 1895 struct super_block *sb = dentry->d_sb; 1896 char *full_path = NULL; 1897 1898 if (inode == NULL) 1899 return -ENOENT; 1900 1901 if (!cifs_inode_needs_reval(inode)) 1902 return rc; 1903 1904 xid = get_xid(); 1905 1906 /* can not safely grab the rename sem here if rename calls revalidate 1907 since that would deadlock */ 1908 full_path = build_path_from_dentry(dentry); 1909 if (full_path == NULL) { 1910 rc = -ENOMEM; 1911 goto out; 1912 } 1913 1914 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n", 1915 full_path, inode, inode->i_count.counter, 1916 dentry, dentry->d_time, jiffies); 1917 1918 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext) 1919 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid); 1920 else 1921 rc = cifs_get_inode_info(&inode, full_path, NULL, sb, 1922 xid, NULL); 1923 1924out: 1925 kfree(full_path); 1926 free_xid(xid); 1927 return rc; 1928} 1929 1930int cifs_revalidate_file(struct file *filp) 1931{ 1932 int rc; 1933 struct inode *inode = file_inode(filp); 1934 1935 rc = cifs_revalidate_file_attr(filp); 1936 if (rc) 1937 return rc; 1938 1939 return cifs_revalidate_mapping(inode); 1940} 1941 1942/* revalidate a dentry's inode attributes */ 1943int cifs_revalidate_dentry(struct dentry *dentry) 1944{ 1945 int rc; 1946 struct inode *inode = d_inode(dentry); 1947 1948 rc = cifs_revalidate_dentry_attr(dentry); 1949 if (rc) 1950 return rc; 1951 1952 return cifs_revalidate_mapping(inode); 1953} 1954 1955int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry, 1956 struct kstat *stat) 1957{ 1958 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb); 1959 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 1960 struct inode *inode = d_inode(dentry); 1961 int rc; 1962 1963 /* 1964 * We need to be sure that all dirty pages are written and the server 1965 * has actual ctime, mtime and file length. 1966 */ 1967 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping && 1968 inode->i_mapping->nrpages != 0) { 1969 rc = filemap_fdatawait(inode->i_mapping); 1970 if (rc) { 1971 mapping_set_error(inode->i_mapping, rc); 1972 return rc; 1973 } 1974 } 1975 1976 rc = cifs_revalidate_dentry_attr(dentry); 1977 if (rc) 1978 return rc; 1979 1980 generic_fillattr(inode, stat); 1981 stat->blksize = CIFS_MAX_MSGSIZE; 1982 stat->ino = CIFS_I(inode)->uniqueid; 1983 1984 /* 1985 * If on a multiuser mount without unix extensions or cifsacl being 1986 * enabled, and the admin hasn't overridden them, set the ownership 1987 * to the fsuid/fsgid of the current process. 1988 */ 1989 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) && 1990 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) && 1991 !tcon->unix_ext) { 1992 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) 1993 stat->uid = current_fsuid(); 1994 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) 1995 stat->gid = current_fsgid(); 1996 } 1997 return rc; 1998} 1999 2000static int cifs_truncate_page(struct address_space *mapping, loff_t from) 2001{ 2002 pgoff_t index = from >> PAGE_CACHE_SHIFT; 2003 unsigned offset = from & (PAGE_CACHE_SIZE - 1); 2004 struct page *page; 2005 int rc = 0; 2006 2007 page = grab_cache_page(mapping, index); 2008 if (!page) 2009 return -ENOMEM; 2010 2011 zero_user_segment(page, offset, PAGE_CACHE_SIZE); 2012 unlock_page(page); 2013 page_cache_release(page); 2014 return rc; 2015} 2016 2017static void cifs_setsize(struct inode *inode, loff_t offset) 2018{ 2019 spin_lock(&inode->i_lock); 2020 i_size_write(inode, offset); 2021 spin_unlock(&inode->i_lock); 2022 2023 truncate_pagecache(inode, offset); 2024} 2025 2026static int 2027cifs_set_file_size(struct inode *inode, struct iattr *attrs, 2028 unsigned int xid, char *full_path) 2029{ 2030 int rc; 2031 struct cifsFileInfo *open_file; 2032 struct cifsInodeInfo *cifsInode = CIFS_I(inode); 2033 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 2034 struct tcon_link *tlink = NULL; 2035 struct cifs_tcon *tcon = NULL; 2036 struct TCP_Server_Info *server; 2037 2038 /* 2039 * To avoid spurious oplock breaks from server, in the case of 2040 * inodes that we already have open, avoid doing path based 2041 * setting of file size if we can do it by handle. 2042 * This keeps our caching token (oplock) and avoids timeouts 2043 * when the local oplock break takes longer to flush 2044 * writebehind data than the SMB timeout for the SetPathInfo 2045 * request would allow 2046 */ 2047 open_file = find_writable_file(cifsInode, true); 2048 if (open_file) { 2049 tcon = tlink_tcon(open_file->tlink); 2050 server = tcon->ses->server; 2051 if (server->ops->set_file_size) 2052 rc = server->ops->set_file_size(xid, tcon, open_file, 2053 attrs->ia_size, false); 2054 else 2055 rc = -ENOSYS; 2056 cifsFileInfo_put(open_file); 2057 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc); 2058 } else 2059 rc = -EINVAL; 2060 2061 if (!rc) 2062 goto set_size_out; 2063 2064 if (tcon == NULL) { 2065 tlink = cifs_sb_tlink(cifs_sb); 2066 if (IS_ERR(tlink)) 2067 return PTR_ERR(tlink); 2068 tcon = tlink_tcon(tlink); 2069 server = tcon->ses->server; 2070 } 2071 2072 /* 2073 * Set file size by pathname rather than by handle either because no 2074 * valid, writeable file handle for it was found or because there was 2075 * an error setting it by handle. 2076 */ 2077 if (server->ops->set_path_size) 2078 rc = server->ops->set_path_size(xid, tcon, full_path, 2079 attrs->ia_size, cifs_sb, false); 2080 else 2081 rc = -ENOSYS; 2082 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc); 2083 2084 if (tlink) 2085 cifs_put_tlink(tlink); 2086 2087set_size_out: 2088 if (rc == 0) { 2089 cifsInode->server_eof = attrs->ia_size; 2090 cifs_setsize(inode, attrs->ia_size); 2091 cifs_truncate_page(inode->i_mapping, inode->i_size); 2092 } 2093 2094 return rc; 2095} 2096 2097static int 2098cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs) 2099{ 2100 int rc; 2101 unsigned int xid; 2102 char *full_path = NULL; 2103 struct inode *inode = d_inode(direntry); 2104 struct cifsInodeInfo *cifsInode = CIFS_I(inode); 2105 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 2106 struct tcon_link *tlink; 2107 struct cifs_tcon *pTcon; 2108 struct cifs_unix_set_info_args *args = NULL; 2109 struct cifsFileInfo *open_file; 2110 2111 cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n", 2112 direntry, attrs->ia_valid); 2113 2114 xid = get_xid(); 2115 2116 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) 2117 attrs->ia_valid |= ATTR_FORCE; 2118 2119 rc = inode_change_ok(inode, attrs); 2120 if (rc < 0) 2121 goto out; 2122 2123 full_path = build_path_from_dentry(direntry); 2124 if (full_path == NULL) { 2125 rc = -ENOMEM; 2126 goto out; 2127 } 2128 2129 /* 2130 * Attempt to flush data before changing attributes. We need to do 2131 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the 2132 * ownership or mode then we may also need to do this. Here, we take 2133 * the safe way out and just do the flush on all setattr requests. If 2134 * the flush returns error, store it to report later and continue. 2135 * 2136 * BB: This should be smarter. Why bother flushing pages that 2137 * will be truncated anyway? Also, should we error out here if 2138 * the flush returns error? 2139 */ 2140 rc = filemap_write_and_wait(inode->i_mapping); 2141 mapping_set_error(inode->i_mapping, rc); 2142 rc = 0; 2143 2144 if (attrs->ia_valid & ATTR_SIZE) { 2145 rc = cifs_set_file_size(inode, attrs, xid, full_path); 2146 if (rc != 0) 2147 goto out; 2148 } 2149 2150 /* skip mode change if it's just for clearing setuid/setgid */ 2151 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) 2152 attrs->ia_valid &= ~ATTR_MODE; 2153 2154 args = kmalloc(sizeof(*args), GFP_KERNEL); 2155 if (args == NULL) { 2156 rc = -ENOMEM; 2157 goto out; 2158 } 2159 2160 /* set up the struct */ 2161 if (attrs->ia_valid & ATTR_MODE) 2162 args->mode = attrs->ia_mode; 2163 else 2164 args->mode = NO_CHANGE_64; 2165 2166 if (attrs->ia_valid & ATTR_UID) 2167 args->uid = attrs->ia_uid; 2168 else 2169 args->uid = INVALID_UID; /* no change */ 2170 2171 if (attrs->ia_valid & ATTR_GID) 2172 args->gid = attrs->ia_gid; 2173 else 2174 args->gid = INVALID_GID; /* no change */ 2175 2176 if (attrs->ia_valid & ATTR_ATIME) 2177 args->atime = cifs_UnixTimeToNT(attrs->ia_atime); 2178 else 2179 args->atime = NO_CHANGE_64; 2180 2181 if (attrs->ia_valid & ATTR_MTIME) 2182 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime); 2183 else 2184 args->mtime = NO_CHANGE_64; 2185 2186 if (attrs->ia_valid & ATTR_CTIME) 2187 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime); 2188 else 2189 args->ctime = NO_CHANGE_64; 2190 2191 args->device = 0; 2192 open_file = find_writable_file(cifsInode, true); 2193 if (open_file) { 2194 u16 nfid = open_file->fid.netfid; 2195 u32 npid = open_file->pid; 2196 pTcon = tlink_tcon(open_file->tlink); 2197 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid); 2198 cifsFileInfo_put(open_file); 2199 } else { 2200 tlink = cifs_sb_tlink(cifs_sb); 2201 if (IS_ERR(tlink)) { 2202 rc = PTR_ERR(tlink); 2203 goto out; 2204 } 2205 pTcon = tlink_tcon(tlink); 2206 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args, 2207 cifs_sb->local_nls, 2208 cifs_remap(cifs_sb)); 2209 cifs_put_tlink(tlink); 2210 } 2211 2212 if (rc) 2213 goto out; 2214 2215 if ((attrs->ia_valid & ATTR_SIZE) && 2216 attrs->ia_size != i_size_read(inode)) 2217 truncate_setsize(inode, attrs->ia_size); 2218 2219 setattr_copy(inode, attrs); 2220 mark_inode_dirty(inode); 2221 2222 /* force revalidate when any of these times are set since some 2223 of the fs types (eg ext3, fat) do not have fine enough 2224 time granularity to match protocol, and we do not have a 2225 a way (yet) to query the server fs's time granularity (and 2226 whether it rounds times down). 2227 */ 2228 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME)) 2229 cifsInode->time = 0; 2230out: 2231 kfree(args); 2232 kfree(full_path); 2233 free_xid(xid); 2234 return rc; 2235} 2236 2237static int 2238cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs) 2239{ 2240 unsigned int xid; 2241 kuid_t uid = INVALID_UID; 2242 kgid_t gid = INVALID_GID; 2243 struct inode *inode = d_inode(direntry); 2244 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 2245 struct cifsInodeInfo *cifsInode = CIFS_I(inode); 2246 char *full_path = NULL; 2247 int rc = -EACCES; 2248 __u32 dosattr = 0; 2249 __u64 mode = NO_CHANGE_64; 2250 2251 xid = get_xid(); 2252 2253 cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n", 2254 direntry, attrs->ia_valid); 2255 2256 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) 2257 attrs->ia_valid |= ATTR_FORCE; 2258 2259 rc = inode_change_ok(inode, attrs); 2260 if (rc < 0) { 2261 free_xid(xid); 2262 return rc; 2263 } 2264 2265 full_path = build_path_from_dentry(direntry); 2266 if (full_path == NULL) { 2267 rc = -ENOMEM; 2268 free_xid(xid); 2269 return rc; 2270 } 2271 2272 /* 2273 * Attempt to flush data before changing attributes. We need to do 2274 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the 2275 * ownership or mode then we may also need to do this. Here, we take 2276 * the safe way out and just do the flush on all setattr requests. If 2277 * the flush returns error, store it to report later and continue. 2278 * 2279 * BB: This should be smarter. Why bother flushing pages that 2280 * will be truncated anyway? Also, should we error out here if 2281 * the flush returns error? 2282 */ 2283 rc = filemap_write_and_wait(inode->i_mapping); 2284 mapping_set_error(inode->i_mapping, rc); 2285 rc = 0; 2286 2287 if (attrs->ia_valid & ATTR_SIZE) { 2288 rc = cifs_set_file_size(inode, attrs, xid, full_path); 2289 if (rc != 0) 2290 goto cifs_setattr_exit; 2291 } 2292 2293 if (attrs->ia_valid & ATTR_UID) 2294 uid = attrs->ia_uid; 2295 2296 if (attrs->ia_valid & ATTR_GID) 2297 gid = attrs->ia_gid; 2298 2299#ifdef CONFIG_CIFS_ACL 2300 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) { 2301 if (uid_valid(uid) || gid_valid(gid)) { 2302 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64, 2303 uid, gid); 2304 if (rc) { 2305 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n", 2306 __func__, rc); 2307 goto cifs_setattr_exit; 2308 } 2309 } 2310 } else 2311#endif /* CONFIG_CIFS_ACL */ 2312 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) 2313 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID); 2314 2315 /* skip mode change if it's just for clearing setuid/setgid */ 2316 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) 2317 attrs->ia_valid &= ~ATTR_MODE; 2318 2319 if (attrs->ia_valid & ATTR_MODE) { 2320 mode = attrs->ia_mode; 2321 rc = 0; 2322#ifdef CONFIG_CIFS_ACL 2323 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) { 2324 rc = id_mode_to_cifs_acl(inode, full_path, mode, 2325 INVALID_UID, INVALID_GID); 2326 if (rc) { 2327 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n", 2328 __func__, rc); 2329 goto cifs_setattr_exit; 2330 } 2331 } else 2332#endif /* CONFIG_CIFS_ACL */ 2333 if (((mode & S_IWUGO) == 0) && 2334 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) { 2335 2336 dosattr = cifsInode->cifsAttrs | ATTR_READONLY; 2337 2338 /* fix up mode if we're not using dynperm */ 2339 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0) 2340 attrs->ia_mode = inode->i_mode & ~S_IWUGO; 2341 } else if ((mode & S_IWUGO) && 2342 (cifsInode->cifsAttrs & ATTR_READONLY)) { 2343 2344 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY; 2345 /* Attributes of 0 are ignored */ 2346 if (dosattr == 0) 2347 dosattr |= ATTR_NORMAL; 2348 2349 /* reset local inode permissions to normal */ 2350 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) { 2351 attrs->ia_mode &= ~(S_IALLUGO); 2352 if (S_ISDIR(inode->i_mode)) 2353 attrs->ia_mode |= 2354 cifs_sb->mnt_dir_mode; 2355 else 2356 attrs->ia_mode |= 2357 cifs_sb->mnt_file_mode; 2358 } 2359 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) { 2360 /* ignore mode change - ATTR_READONLY hasn't changed */ 2361 attrs->ia_valid &= ~ATTR_MODE; 2362 } 2363 } 2364 2365 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) || 2366 ((attrs->ia_valid & ATTR_MODE) && dosattr)) { 2367 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr); 2368 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */ 2369 2370 /* Even if error on time set, no sense failing the call if 2371 the server would set the time to a reasonable value anyway, 2372 and this check ensures that we are not being called from 2373 sys_utimes in which case we ought to fail the call back to 2374 the user when the server rejects the call */ 2375 if ((rc) && (attrs->ia_valid & 2376 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE))) 2377 rc = 0; 2378 } 2379 2380 /* do not need local check to inode_check_ok since the server does 2381 that */ 2382 if (rc) 2383 goto cifs_setattr_exit; 2384 2385 if ((attrs->ia_valid & ATTR_SIZE) && 2386 attrs->ia_size != i_size_read(inode)) 2387 truncate_setsize(inode, attrs->ia_size); 2388 2389 setattr_copy(inode, attrs); 2390 mark_inode_dirty(inode); 2391 2392cifs_setattr_exit: 2393 kfree(full_path); 2394 free_xid(xid); 2395 return rc; 2396} 2397 2398int 2399cifs_setattr(struct dentry *direntry, struct iattr *attrs) 2400{ 2401 struct inode *inode = d_inode(direntry); 2402 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 2403 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb); 2404 2405 if (pTcon->unix_ext) 2406 return cifs_setattr_unix(direntry, attrs); 2407 2408 return cifs_setattr_nounix(direntry, attrs); 2409 2410 /* BB: add cifs_setattr_legacy for really old servers */ 2411} 2412 2413#if 0 2414void cifs_delete_inode(struct inode *inode) 2415{ 2416 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode); 2417 /* may have to add back in if and when safe distributed caching of 2418 directories added e.g. via FindNotify */ 2419} 2420#endif 2421