1// SPDX-License-Identifier: LGPL-2.1 2/* 3 * 4 * vfs operations that deal with dentries 5 * 6 * Copyright (C) International Business Machines Corp., 2002,2009 7 * Author(s): Steve French (sfrench@us.ibm.com) 8 * 9 */ 10#include <linux/fs.h> 11#include <linux/stat.h> 12#include <linux/slab.h> 13#include <linux/namei.h> 14#include <linux/mount.h> 15#include <linux/file.h> 16#include "cifsfs.h" 17#include "cifspdu.h" 18#include "cifsglob.h" 19#include "cifsproto.h" 20#include "cifs_debug.h" 21#include "cifs_fs_sb.h" 22#include "cifs_unicode.h" 23#include "fs_context.h" 24#include "cifs_ioctl.h" 25#include "fscache.h" 26 27static void 28renew_parental_timestamps(struct dentry *direntry) 29{ 30 /* BB check if there is a way to get the kernel to do this or if we 31 really need this */ 32 do { 33 cifs_set_time(direntry, jiffies); 34 direntry = direntry->d_parent; 35 } while (!IS_ROOT(direntry)); 36} 37 38char * 39cifs_build_path_to_root(struct smb3_fs_context *ctx, struct cifs_sb_info *cifs_sb, 40 struct cifs_tcon *tcon, int add_treename) 41{ 42 int pplen = ctx->prepath ? strlen(ctx->prepath) + 1 : 0; 43 int dfsplen; 44 char *full_path = NULL; 45 46 /* if no prefix path, simply set path to the root of share to "" */ 47 if (pplen == 0) { 48 full_path = kzalloc(1, GFP_KERNEL); 49 return full_path; 50 } 51 52 if (add_treename) 53 dfsplen = strnlen(tcon->tree_name, MAX_TREE_SIZE + 1); 54 else 55 dfsplen = 0; 56 57 full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL); 58 if (full_path == NULL) 59 return full_path; 60 61 if (dfsplen) 62 memcpy(full_path, tcon->tree_name, dfsplen); 63 full_path[dfsplen] = CIFS_DIR_SEP(cifs_sb); 64 memcpy(full_path + dfsplen + 1, ctx->prepath, pplen); 65 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb)); 66 return full_path; 67} 68 69/* Note: caller must free return buffer */ 70const char * 71build_path_from_dentry(struct dentry *direntry, void *page) 72{ 73 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb); 74 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 75 bool prefix = tcon->Flags & SMB_SHARE_IS_IN_DFS; 76 77 return build_path_from_dentry_optional_prefix(direntry, page, 78 prefix); 79} 80 81char *__build_path_from_dentry_optional_prefix(struct dentry *direntry, void *page, 82 const char *tree, int tree_len, 83 bool prefix) 84{ 85 int dfsplen; 86 int pplen = 0; 87 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb); 88 char dirsep = CIFS_DIR_SEP(cifs_sb); 89 char *s; 90 91 if (unlikely(!page)) 92 return ERR_PTR(-ENOMEM); 93 94 if (prefix) 95 dfsplen = strnlen(tree, tree_len + 1); 96 else 97 dfsplen = 0; 98 99 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) 100 pplen = cifs_sb->prepath ? strlen(cifs_sb->prepath) + 1 : 0; 101 102 s = dentry_path_raw(direntry, page, PATH_MAX); 103 if (IS_ERR(s)) 104 return s; 105 if (!s[1]) // for root we want "", not "/" 106 s++; 107 if (s < (char *)page + pplen + dfsplen) 108 return ERR_PTR(-ENAMETOOLONG); 109 if (pplen) { 110 cifs_dbg(FYI, "using cifs_sb prepath <%s>\n", cifs_sb->prepath); 111 s -= pplen; 112 memcpy(s + 1, cifs_sb->prepath, pplen - 1); 113 *s = '/'; 114 } 115 if (dirsep != '/') { 116 /* BB test paths to Windows with '/' in the midst of prepath */ 117 char *p; 118 119 for (p = s; *p; p++) 120 if (*p == '/') 121 *p = dirsep; 122 } 123 if (dfsplen) { 124 s -= dfsplen; 125 memcpy(s, tree, dfsplen); 126 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) { 127 int i; 128 for (i = 0; i < dfsplen; i++) { 129 if (s[i] == '\\') 130 s[i] = '/'; 131 } 132 } 133 } 134 return s; 135} 136 137char *build_path_from_dentry_optional_prefix(struct dentry *direntry, void *page, 138 bool prefix) 139{ 140 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb); 141 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 142 143 return __build_path_from_dentry_optional_prefix(direntry, page, tcon->tree_name, 144 MAX_TREE_SIZE, prefix); 145} 146 147/* 148 * Don't allow path components longer than the server max. 149 * Don't allow the separator character in a path component. 150 * The VFS will not allow "/", but "\" is allowed by posix. 151 */ 152static int 153check_name(struct dentry *direntry, struct cifs_tcon *tcon) 154{ 155 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb); 156 int i; 157 158 if (unlikely(tcon->fsAttrInfo.MaxPathNameComponentLength && 159 direntry->d_name.len > 160 le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength))) 161 return -ENAMETOOLONG; 162 163 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) { 164 for (i = 0; i < direntry->d_name.len; i++) { 165 if (direntry->d_name.name[i] == '\\') { 166 cifs_dbg(FYI, "Invalid file name\n"); 167 return -EINVAL; 168 } 169 } 170 } 171 return 0; 172} 173 174 175/* Inode operations in similar order to how they appear in Linux file fs.h */ 176 177static int cifs_do_create(struct inode *inode, struct dentry *direntry, unsigned int xid, 178 struct tcon_link *tlink, unsigned int oflags, umode_t mode, __u32 *oplock, 179 struct cifs_fid *fid, struct cifs_open_info_data *buf) 180{ 181 int rc = -ENOENT; 182 int create_options = CREATE_NOT_DIR; 183 int desired_access; 184 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 185 struct cifs_tcon *tcon = tlink_tcon(tlink); 186 const char *full_path; 187 void *page = alloc_dentry_path(); 188 struct inode *newinode = NULL; 189 int disposition; 190 struct TCP_Server_Info *server = tcon->ses->server; 191 struct cifs_open_parms oparms; 192 int rdwr_for_fscache = 0; 193 194 *oplock = 0; 195 if (tcon->ses->server->oplocks) 196 *oplock = REQ_OPLOCK; 197 198 full_path = build_path_from_dentry(direntry, page); 199 if (IS_ERR(full_path)) { 200 free_dentry_path(page); 201 return PTR_ERR(full_path); 202 } 203 204 /* If we're caching, we need to be able to fill in around partial writes. */ 205 if (cifs_fscache_enabled(inode) && (oflags & O_ACCMODE) == O_WRONLY) 206 rdwr_for_fscache = 1; 207 208#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 209 if (tcon->unix_ext && cap_unix(tcon->ses) && !tcon->broken_posix_open && 210 (CIFS_UNIX_POSIX_PATH_OPS_CAP & 211 le64_to_cpu(tcon->fsUnixInfo.Capability))) { 212 rc = cifs_posix_open(full_path, &newinode, inode->i_sb, mode, 213 oflags, oplock, &fid->netfid, xid); 214 switch (rc) { 215 case 0: 216 if (newinode == NULL) { 217 /* query inode info */ 218 goto cifs_create_get_file_info; 219 } 220 221 if (S_ISDIR(newinode->i_mode)) { 222 CIFSSMBClose(xid, tcon, fid->netfid); 223 iput(newinode); 224 rc = -EISDIR; 225 goto out; 226 } 227 228 if (!S_ISREG(newinode->i_mode)) { 229 /* 230 * The server may allow us to open things like 231 * FIFOs, but the client isn't set up to deal 232 * with that. If it's not a regular file, just 233 * close it and proceed as if it were a normal 234 * lookup. 235 */ 236 CIFSSMBClose(xid, tcon, fid->netfid); 237 goto cifs_create_get_file_info; 238 } 239 /* success, no need to query */ 240 goto cifs_create_set_dentry; 241 242 case -ENOENT: 243 goto cifs_create_get_file_info; 244 245 case -EIO: 246 case -EINVAL: 247 /* 248 * EIO could indicate that (posix open) operation is not 249 * supported, despite what server claimed in capability 250 * negotiation. 251 * 252 * POSIX open in samba versions 3.3.1 and earlier could 253 * incorrectly fail with invalid parameter. 254 */ 255 tcon->broken_posix_open = true; 256 break; 257 258 case -EREMOTE: 259 case -EOPNOTSUPP: 260 /* 261 * EREMOTE indicates DFS junction, which is not handled 262 * in posix open. If either that or op not supported 263 * returned, follow the normal lookup. 264 */ 265 break; 266 267 default: 268 goto out; 269 } 270 /* 271 * fallthrough to retry, using older open call, this is case 272 * where server does not support this SMB level, and falsely 273 * claims capability (also get here for DFS case which should be 274 * rare for path not covered on files) 275 */ 276 } 277#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 278 279 desired_access = 0; 280 if (OPEN_FMODE(oflags) & FMODE_READ) 281 desired_access |= GENERIC_READ; /* is this too little? */ 282 if (OPEN_FMODE(oflags) & FMODE_WRITE) 283 desired_access |= GENERIC_WRITE; 284 if (rdwr_for_fscache == 1) 285 desired_access |= GENERIC_READ; 286 287 disposition = FILE_OVERWRITE_IF; 288 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) 289 disposition = FILE_CREATE; 290 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC)) 291 disposition = FILE_OVERWRITE_IF; 292 else if ((oflags & O_CREAT) == O_CREAT) 293 disposition = FILE_OPEN_IF; 294 else 295 cifs_dbg(FYI, "Create flag not set in create function\n"); 296 297 /* 298 * BB add processing to set equivalent of mode - e.g. via CreateX with 299 * ACLs 300 */ 301 302 if (!server->ops->open) { 303 rc = -ENOSYS; 304 goto out; 305 } 306 307 /* 308 * if we're not using unix extensions, see if we need to set 309 * ATTR_READONLY on the create call 310 */ 311 if (!tcon->unix_ext && (mode & S_IWUGO) == 0) 312 create_options |= CREATE_OPTION_READONLY; 313 314retry_open: 315 oparms = (struct cifs_open_parms) { 316 .tcon = tcon, 317 .cifs_sb = cifs_sb, 318 .desired_access = desired_access, 319 .create_options = cifs_create_options(cifs_sb, create_options), 320 .disposition = disposition, 321 .path = full_path, 322 .fid = fid, 323 .mode = mode, 324 }; 325 rc = server->ops->open(xid, &oparms, oplock, buf); 326 if (rc) { 327 cifs_dbg(FYI, "cifs_create returned 0x%x\n", rc); 328 if (rc == -EACCES && rdwr_for_fscache == 1) { 329 desired_access &= ~GENERIC_READ; 330 rdwr_for_fscache = 2; 331 goto retry_open; 332 } 333 goto out; 334 } 335 if (rdwr_for_fscache == 2) 336 cifs_invalidate_cache(inode, FSCACHE_INVAL_DIO_WRITE); 337 338#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 339 /* 340 * If Open reported that we actually created a file then we now have to 341 * set the mode if possible. 342 */ 343 if ((tcon->unix_ext) && (*oplock & CIFS_CREATE_ACTION)) { 344 struct cifs_unix_set_info_args args = { 345 .mode = mode, 346 .ctime = NO_CHANGE_64, 347 .atime = NO_CHANGE_64, 348 .mtime = NO_CHANGE_64, 349 .device = 0, 350 }; 351 352 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) { 353 args.uid = current_fsuid(); 354 if (inode->i_mode & S_ISGID) 355 args.gid = inode->i_gid; 356 else 357 args.gid = current_fsgid(); 358 } else { 359 args.uid = INVALID_UID; /* no change */ 360 args.gid = INVALID_GID; /* no change */ 361 } 362 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid->netfid, 363 current->tgid); 364 } else { 365 /* 366 * BB implement mode setting via Windows security 367 * descriptors e.g. 368 */ 369 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/ 370 371 /* Could set r/o dos attribute if mode & 0222 == 0 */ 372 } 373 374cifs_create_get_file_info: 375 /* server might mask mode so we have to query for it */ 376 if (tcon->unix_ext) 377 rc = cifs_get_inode_info_unix(&newinode, full_path, inode->i_sb, 378 xid); 379 else { 380#else 381 { 382#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 383 /* TODO: Add support for calling POSIX query info here, but passing in fid */ 384 rc = cifs_get_inode_info(&newinode, full_path, buf, inode->i_sb, xid, fid); 385 if (newinode) { 386 if (server->ops->set_lease_key) 387 server->ops->set_lease_key(newinode, fid); 388 if ((*oplock & CIFS_CREATE_ACTION) && S_ISREG(newinode->i_mode)) { 389 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) 390 newinode->i_mode = mode; 391 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) { 392 newinode->i_uid = current_fsuid(); 393 if (inode->i_mode & S_ISGID) 394 newinode->i_gid = inode->i_gid; 395 else 396 newinode->i_gid = current_fsgid(); 397 } 398 } 399 } 400 } 401 402#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 403cifs_create_set_dentry: 404#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 405 if (rc != 0) { 406 cifs_dbg(FYI, "Create worked, get_inode_info failed rc = %d\n", 407 rc); 408 goto out_err; 409 } 410 411 if (newinode) 412 if (S_ISDIR(newinode->i_mode)) { 413 rc = -EISDIR; 414 goto out_err; 415 } 416 417 d_drop(direntry); 418 d_add(direntry, newinode); 419 420out: 421 free_dentry_path(page); 422 return rc; 423 424out_err: 425 if (server->ops->close) 426 server->ops->close(xid, tcon, fid); 427 if (newinode) 428 iput(newinode); 429 goto out; 430} 431 432int 433cifs_atomic_open(struct inode *inode, struct dentry *direntry, 434 struct file *file, unsigned oflags, umode_t mode) 435{ 436 int rc; 437 unsigned int xid; 438 struct tcon_link *tlink; 439 struct cifs_tcon *tcon; 440 struct TCP_Server_Info *server; 441 struct cifs_fid fid = {}; 442 struct cifs_pending_open open; 443 __u32 oplock; 444 struct cifsFileInfo *file_info; 445 struct cifs_open_info_data buf = {}; 446 447 if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb)))) 448 return -EIO; 449 450 /* 451 * Posix open is only called (at lookup time) for file create now. For 452 * opens (rather than creates), because we do not know if it is a file 453 * or directory yet, and current Samba no longer allows us to do posix 454 * open on dirs, we could end up wasting an open call on what turns out 455 * to be a dir. For file opens, we wait to call posix open till 456 * cifs_open. It could be added to atomic_open in the future but the 457 * performance tradeoff of the extra network request when EISDIR or 458 * EACCES is returned would have to be weighed against the 50% reduction 459 * in network traffic in the other paths. 460 */ 461 if (!(oflags & O_CREAT)) { 462 struct dentry *res; 463 464 /* 465 * Check for hashed negative dentry. We have already revalidated 466 * the dentry and it is fine. No need to perform another lookup. 467 */ 468 if (!d_in_lookup(direntry)) 469 return -ENOENT; 470 471 res = cifs_lookup(inode, direntry, 0); 472 if (IS_ERR(res)) 473 return PTR_ERR(res); 474 475 return finish_no_open(file, res); 476 } 477 478 xid = get_xid(); 479 480 cifs_dbg(FYI, "parent inode = 0x%p name is: %pd and dentry = 0x%p\n", 481 inode, direntry, direntry); 482 483 tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb)); 484 if (IS_ERR(tlink)) { 485 rc = PTR_ERR(tlink); 486 goto out_free_xid; 487 } 488 489 tcon = tlink_tcon(tlink); 490 491 rc = check_name(direntry, tcon); 492 if (rc) 493 goto out; 494 495 server = tcon->ses->server; 496 497 if (server->ops->new_lease_key) 498 server->ops->new_lease_key(&fid); 499 500 cifs_add_pending_open(&fid, tlink, &open); 501 502 rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode, 503 &oplock, &fid, &buf); 504 if (rc) { 505 cifs_del_pending_open(&open); 506 goto out; 507 } 508 509 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) 510 file->f_mode |= FMODE_CREATED; 511 512 rc = finish_open(file, direntry, generic_file_open); 513 if (rc) { 514 if (server->ops->close) 515 server->ops->close(xid, tcon, &fid); 516 cifs_del_pending_open(&open); 517 goto out; 518 } 519 520 if (file->f_flags & O_DIRECT && 521 CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) { 522 if (CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NO_BRL) 523 file->f_op = &cifs_file_direct_nobrl_ops; 524 else 525 file->f_op = &cifs_file_direct_ops; 526 } 527 528 file_info = cifs_new_fileinfo(&fid, file, tlink, oplock, buf.symlink_target); 529 if (file_info == NULL) { 530 if (server->ops->close) 531 server->ops->close(xid, tcon, &fid); 532 cifs_del_pending_open(&open); 533 rc = -ENOMEM; 534 goto out; 535 } 536 537 fscache_use_cookie(cifs_inode_cookie(file_inode(file)), 538 file->f_mode & FMODE_WRITE); 539 540out: 541 cifs_put_tlink(tlink); 542out_free_xid: 543 free_xid(xid); 544 cifs_free_open_info(&buf); 545 return rc; 546} 547 548int cifs_create(struct mnt_idmap *idmap, struct inode *inode, 549 struct dentry *direntry, umode_t mode, bool excl) 550{ 551 int rc; 552 unsigned int xid = get_xid(); 553 /* 554 * BB below access is probably too much for mknod to request 555 * but we have to do query and setpathinfo so requesting 556 * less could fail (unless we want to request getatr and setatr 557 * permissions (only). At least for POSIX we do not have to 558 * request so much. 559 */ 560 unsigned oflags = O_EXCL | O_CREAT | O_RDWR; 561 struct tcon_link *tlink; 562 struct cifs_tcon *tcon; 563 struct TCP_Server_Info *server; 564 struct cifs_fid fid; 565 __u32 oplock; 566 struct cifs_open_info_data buf = {}; 567 568 cifs_dbg(FYI, "cifs_create parent inode = 0x%p name is: %pd and dentry = 0x%p\n", 569 inode, direntry, direntry); 570 571 if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb)))) { 572 rc = -EIO; 573 goto out_free_xid; 574 } 575 576 tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb)); 577 rc = PTR_ERR(tlink); 578 if (IS_ERR(tlink)) 579 goto out_free_xid; 580 581 tcon = tlink_tcon(tlink); 582 server = tcon->ses->server; 583 584 if (server->ops->new_lease_key) 585 server->ops->new_lease_key(&fid); 586 587 rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode, &oplock, &fid, &buf); 588 if (!rc && server->ops->close) 589 server->ops->close(xid, tcon, &fid); 590 591 cifs_free_open_info(&buf); 592 cifs_put_tlink(tlink); 593out_free_xid: 594 free_xid(xid); 595 return rc; 596} 597 598int cifs_mknod(struct mnt_idmap *idmap, struct inode *inode, 599 struct dentry *direntry, umode_t mode, dev_t device_number) 600{ 601 int rc = -EPERM; 602 unsigned int xid; 603 struct cifs_sb_info *cifs_sb; 604 struct tcon_link *tlink; 605 struct cifs_tcon *tcon; 606 const char *full_path; 607 void *page; 608 609 if (!old_valid_dev(device_number)) 610 return -EINVAL; 611 612 cifs_sb = CIFS_SB(inode->i_sb); 613 if (unlikely(cifs_forced_shutdown(cifs_sb))) 614 return -EIO; 615 616 tlink = cifs_sb_tlink(cifs_sb); 617 if (IS_ERR(tlink)) 618 return PTR_ERR(tlink); 619 620 page = alloc_dentry_path(); 621 tcon = tlink_tcon(tlink); 622 xid = get_xid(); 623 624 full_path = build_path_from_dentry(direntry, page); 625 if (IS_ERR(full_path)) { 626 rc = PTR_ERR(full_path); 627 goto mknod_out; 628 } 629 630 trace_smb3_mknod_enter(xid, tcon->ses->Suid, tcon->tid, full_path); 631 632 rc = tcon->ses->server->ops->make_node(xid, inode, direntry, tcon, 633 full_path, mode, 634 device_number); 635 636mknod_out: 637 if (rc) 638 trace_smb3_mknod_err(xid, tcon->ses->Suid, tcon->tid, rc); 639 else 640 trace_smb3_mknod_done(xid, tcon->ses->Suid, tcon->tid); 641 642 free_dentry_path(page); 643 free_xid(xid); 644 cifs_put_tlink(tlink); 645 return rc; 646} 647 648struct dentry * 649cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry, 650 unsigned int flags) 651{ 652 unsigned int xid; 653 int rc = 0; /* to get around spurious gcc warning, set to zero here */ 654 struct cifs_sb_info *cifs_sb; 655 struct tcon_link *tlink; 656 struct cifs_tcon *pTcon; 657 struct inode *newInode = NULL; 658 const char *full_path; 659 void *page; 660 int retry_count = 0; 661 662 xid = get_xid(); 663 664 cifs_dbg(FYI, "parent inode = 0x%p name is: %pd and dentry = 0x%p\n", 665 parent_dir_inode, direntry, direntry); 666 667 /* check whether path exists */ 668 669 cifs_sb = CIFS_SB(parent_dir_inode->i_sb); 670 tlink = cifs_sb_tlink(cifs_sb); 671 if (IS_ERR(tlink)) { 672 free_xid(xid); 673 return ERR_CAST(tlink); 674 } 675 pTcon = tlink_tcon(tlink); 676 677 rc = check_name(direntry, pTcon); 678 if (unlikely(rc)) { 679 cifs_put_tlink(tlink); 680 free_xid(xid); 681 return ERR_PTR(rc); 682 } 683 684 /* can not grab the rename sem here since it would 685 deadlock in the cases (beginning of sys_rename itself) 686 in which we already have the sb rename sem */ 687 page = alloc_dentry_path(); 688 full_path = build_path_from_dentry(direntry, page); 689 if (IS_ERR(full_path)) { 690 cifs_put_tlink(tlink); 691 free_xid(xid); 692 free_dentry_path(page); 693 return ERR_CAST(full_path); 694 } 695 696 if (d_really_is_positive(direntry)) { 697 cifs_dbg(FYI, "non-NULL inode in lookup\n"); 698 } else { 699 cifs_dbg(FYI, "NULL inode in lookup\n"); 700 } 701 cifs_dbg(FYI, "Full path: %s inode = 0x%p\n", 702 full_path, d_inode(direntry)); 703 704again: 705 if (pTcon->posix_extensions) { 706 rc = smb311_posix_get_inode_info(&newInode, full_path, NULL, 707 parent_dir_inode->i_sb, xid); 708 } else if (pTcon->unix_ext) { 709 rc = cifs_get_inode_info_unix(&newInode, full_path, 710 parent_dir_inode->i_sb, xid); 711 } else { 712 rc = cifs_get_inode_info(&newInode, full_path, NULL, 713 parent_dir_inode->i_sb, xid, NULL); 714 } 715 716 if (rc == 0) { 717 /* since paths are not looked up by component - the parent 718 directories are presumed to be good here */ 719 renew_parental_timestamps(direntry); 720 } else if (rc == -EAGAIN && retry_count++ < 10) { 721 goto again; 722 } else if (rc == -ENOENT) { 723 cifs_set_time(direntry, jiffies); 724 newInode = NULL; 725 } else { 726 if (rc != -EACCES) { 727 cifs_dbg(FYI, "Unexpected lookup error %d\n", rc); 728 /* We special case check for Access Denied - since that 729 is a common return code */ 730 } 731 newInode = ERR_PTR(rc); 732 } 733 free_dentry_path(page); 734 cifs_put_tlink(tlink); 735 free_xid(xid); 736 return d_splice_alias(newInode, direntry); 737} 738 739static int 740cifs_d_revalidate(struct dentry *direntry, unsigned int flags) 741{ 742 struct inode *inode; 743 int rc; 744 745 if (flags & LOOKUP_RCU) 746 return -ECHILD; 747 748 if (d_really_is_positive(direntry)) { 749 inode = d_inode(direntry); 750 if ((flags & LOOKUP_REVAL) && !CIFS_CACHE_READ(CIFS_I(inode))) 751 CIFS_I(inode)->time = 0; /* force reval */ 752 753 rc = cifs_revalidate_dentry(direntry); 754 if (rc) { 755 cifs_dbg(FYI, "cifs_revalidate_dentry failed with rc=%d", rc); 756 switch (rc) { 757 case -ENOENT: 758 case -ESTALE: 759 /* 760 * Those errors mean the dentry is invalid 761 * (file was deleted or recreated) 762 */ 763 return 0; 764 default: 765 /* 766 * Otherwise some unexpected error happened 767 * report it as-is to VFS layer 768 */ 769 return rc; 770 } 771 } 772 else { 773 /* 774 * If the inode wasn't known to be a dfs entry when 775 * the dentry was instantiated, such as when created 776 * via ->readdir(), it needs to be set now since the 777 * attributes will have been updated by 778 * cifs_revalidate_dentry(). 779 */ 780 if (IS_AUTOMOUNT(inode) && 781 !(direntry->d_flags & DCACHE_NEED_AUTOMOUNT)) { 782 spin_lock(&direntry->d_lock); 783 direntry->d_flags |= DCACHE_NEED_AUTOMOUNT; 784 spin_unlock(&direntry->d_lock); 785 } 786 787 return 1; 788 } 789 } 790 791 /* 792 * This may be nfsd (or something), anyway, we can't see the 793 * intent of this. So, since this can be for creation, drop it. 794 */ 795 if (!flags) 796 return 0; 797 798 /* 799 * Drop the negative dentry, in order to make sure to use the 800 * case sensitive name which is specified by user if this is 801 * for creation. 802 */ 803 if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET)) 804 return 0; 805 806 if (time_after(jiffies, cifs_get_time(direntry) + HZ) || !lookupCacheEnabled) 807 return 0; 808 809 return 1; 810} 811 812/* static int cifs_d_delete(struct dentry *direntry) 813{ 814 int rc = 0; 815 816 cifs_dbg(FYI, "In cifs d_delete, name = %pd\n", direntry); 817 818 return rc; 819} */ 820 821const struct dentry_operations cifs_dentry_ops = { 822 .d_revalidate = cifs_d_revalidate, 823 .d_automount = cifs_d_automount, 824/* d_delete: cifs_d_delete, */ /* not needed except for debugging */ 825}; 826 827static int cifs_ci_hash(const struct dentry *dentry, struct qstr *q) 828{ 829 struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls; 830 unsigned long hash; 831 wchar_t c; 832 int i, charlen; 833 834 hash = init_name_hash(dentry); 835 for (i = 0; i < q->len; i += charlen) { 836 charlen = codepage->char2uni(&q->name[i], q->len - i, &c); 837 /* error out if we can't convert the character */ 838 if (unlikely(charlen < 0)) 839 return charlen; 840 hash = partial_name_hash(cifs_toupper(c), hash); 841 } 842 q->hash = end_name_hash(hash); 843 844 return 0; 845} 846 847static int cifs_ci_compare(const struct dentry *dentry, 848 unsigned int len, const char *str, const struct qstr *name) 849{ 850 struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls; 851 wchar_t c1, c2; 852 int i, l1, l2; 853 854 /* 855 * We make the assumption here that uppercase characters in the local 856 * codepage are always the same length as their lowercase counterparts. 857 * 858 * If that's ever not the case, then this will fail to match it. 859 */ 860 if (name->len != len) 861 return 1; 862 863 for (i = 0; i < len; i += l1) { 864 /* Convert characters in both strings to UTF-16. */ 865 l1 = codepage->char2uni(&str[i], len - i, &c1); 866 l2 = codepage->char2uni(&name->name[i], name->len - i, &c2); 867 868 /* 869 * If we can't convert either character, just declare it to 870 * be 1 byte long and compare the original byte. 871 */ 872 if (unlikely(l1 < 0 && l2 < 0)) { 873 if (str[i] != name->name[i]) 874 return 1; 875 l1 = 1; 876 continue; 877 } 878 879 /* 880 * Here, we again ass|u|me that upper/lowercase versions of 881 * a character are the same length in the local NLS. 882 */ 883 if (l1 != l2) 884 return 1; 885 886 /* Now compare uppercase versions of these characters */ 887 if (cifs_toupper(c1) != cifs_toupper(c2)) 888 return 1; 889 } 890 891 return 0; 892} 893 894const struct dentry_operations cifs_ci_dentry_ops = { 895 .d_revalidate = cifs_d_revalidate, 896 .d_hash = cifs_ci_hash, 897 .d_compare = cifs_ci_compare, 898 .d_automount = cifs_d_automount, 899}; 900