900 lines · c
1// SPDX-License-Identifier: LGPL-2.12/*3 *4 * vfs operations that deal with dentries5 *6 * Copyright (C) International Business Machines Corp., 2002,20097 * 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 void28renew_parental_timestamps(struct dentry *direntry)29{30 /* BB check if there is a way to get the kernel to do this or if we31 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 else55 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 else97 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 int153check_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_LEGACY209 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 like231 * FIFOs, but the client isn't set up to deal232 * with that. If it's not a regular file, just233 * close it and proceed as if it were a normal234 * 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 not249 * supported, despite what server claimed in capability250 * negotiation.251 *252 * POSIX open in samba versions 3.3.1 and earlier could253 * 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 handled262 * in posix open. If either that or op not supported263 * 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 case272 * where server does not support this SMB level, and falsely273 * claims capability (also get here for DFS case which should be274 * 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 else295 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 with299 * ACLs300 */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 set309 * ATTR_READONLY on the create call310 */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_LEGACY339 /*340 * If Open reported that we actually created a file then we now have to341 * 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 else357 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 security367 * 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#else381 {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 else396 newinode->i_gid = current_fsgid();397 }398 }399 }400 }401 402#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY403cifs_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 432int433cifs_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. For452 * opens (rather than creates), because we do not know if it is a file453 * or directory yet, and current Samba no longer allows us to do posix454 * open on dirs, we could end up wasting an open call on what turns out455 * to be a dir. For file opens, we wait to call posix open till456 * cifs_open. It could be added to atomic_open in the future but the457 * performance tradeoff of the extra network request when EISDIR or458 * EACCES is returned would have to be weighed against the 50% reduction459 * 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 revalidated466 * 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 else525 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 request555 * but we have to do query and setpathinfo so requesting556 * less could fail (unless we want to request getatr and setatr557 * permissions (only). At least for POSIX we do not have to558 * 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 else640 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 would685 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 parent718 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 that729 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 int740cifs_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 invalid761 * (file was deleted or recreated)762 */763 return 0;764 default:765 /*766 * Otherwise some unexpected error happened767 * report it as-is to VFS layer768 */769 return rc;770 }771 }772 else {773 /*774 * If the inode wasn't known to be a dfs entry when775 * the dentry was instantiated, such as when created776 * via ->readdir(), it needs to be set now since the777 * attributes will have been updated by778 * 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 the793 * 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 the800 * case sensitive name which is specified by user if this is801 * 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 local856 * 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 to870 * 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 of881 * 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