fs/smb/client/dir.c

   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
  27 static void
  28 renew_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
  38 char *
  39 cifs_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 */
  70 const char *
  71 build_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
  81 char *__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
 137 char *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  */
 152 static int
 153 check_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
 177 static 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
 193         *oplock = 0;
 194         if (tcon->ses->server->oplocks)
 195                 *oplock = REQ_OPLOCK;
 196
 197         full_path = build_path_from_dentry(direntry, page);
 198         if (IS_ERR(full_path)) {
 199                 free_dentry_path(page);
 200                 return PTR_ERR(full_path);
 201         }
 202
 203 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 204         if (tcon->unix_ext && cap_unix(tcon->ses) && !tcon->broken_posix_open &&
 205             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 206                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 207                 rc = cifs_posix_open(full_path, &newinode, inode->i_sb, mode,
 208                                      oflags, oplock, &fid->netfid, xid);
 209                 switch (rc) {
 210                 case 0:
 211                         if (newinode == NULL) {
 212                                 /* query inode info */
 213                                 goto cifs_create_get_file_info;
 214                         }
 215
 216                         if (S_ISDIR(newinode->i_mode)) {
 217                                 CIFSSMBClose(xid, tcon, fid->netfid);
 218                                 iput(newinode);
 219                                 rc = -EISDIR;
 220                                 goto out;
 221                         }
 222
 223                         if (!S_ISREG(newinode->i_mode)) {
 224                                 /*
 225                                  * The server may allow us to open things like
 226                                  * FIFOs, but the client isn't set up to deal
 227                                  * with that. If it's not a regular file, just
 228                                  * close it and proceed as if it were a normal
 229                                  * lookup.
 230                                  */
 231                                 CIFSSMBClose(xid, tcon, fid->netfid);
 232                                 goto cifs_create_get_file_info;
 233                         }
 234                         /* success, no need to query */
 235                         goto cifs_create_set_dentry;
 236
 237                 case -ENOENT:
 238                         goto cifs_create_get_file_info;
 239
 240                 case -EIO:
 241                 case -EINVAL:
 242                         /*
 243                          * EIO could indicate that (posix open) operation is not
 244                          * supported, despite what server claimed in capability
 245                          * negotiation.
 246                          *
 247                          * POSIX open in samba versions 3.3.1 and earlier could
 248                          * incorrectly fail with invalid parameter.
 249                          */
 250                         tcon->broken_posix_open = true;
 251                         break;
 252
 253                 case -EREMOTE:
 254                 case -EOPNOTSUPP:
 255                         /*
 256                          * EREMOTE indicates DFS junction, which is not handled
 257                          * in posix open.  If either that or op not supported
 258                          * returned, follow the normal lookup.
 259                          */
 260                         break;
 261
 262                 default:
 263                         goto out;
 264                 }
 265                 /*
 266                  * fallthrough to retry, using older open call, this is case
 267                  * where server does not support this SMB level, and falsely
 268                  * claims capability (also get here for DFS case which should be
 269                  * rare for path not covered on files)
 270                  */
 271         }
 272 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 273
 274         desired_access = 0;
 275         if (OPEN_FMODE(oflags) & FMODE_READ)
 276                 desired_access |= GENERIC_READ; /* is this too little? */
 277         if (OPEN_FMODE(oflags) & FMODE_WRITE)
 278                 desired_access |= GENERIC_WRITE;
 279
 280         disposition = FILE_OVERWRITE_IF;
 281         if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 282                 disposition = FILE_CREATE;
 283         else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
 284                 disposition = FILE_OVERWRITE_IF;
 285         else if ((oflags & O_CREAT) == O_CREAT)
 286                 disposition = FILE_OPEN_IF;
 287         else
 288                 cifs_dbg(FYI, "Create flag not set in create function\n");
 289
 290         /*
 291          * BB add processing to set equivalent of mode - e.g. via CreateX with
 292          * ACLs
 293          */
 294
 295         if (!server->ops->open) {
 296                 rc = -ENOSYS;
 297                 goto out;
 298         }
 299
 300         /*
 301          * if we're not using unix extensions, see if we need to set
 302          * ATTR_READONLY on the create call
 303          */
 304         if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
 305                 create_options |= CREATE_OPTION_READONLY;
 306
 307         oparms = (struct cifs_open_parms) {
 308                 .tcon = tcon,
 309                 .cifs_sb = cifs_sb,
 310                 .desired_access = desired_access,
 311                 .create_options = cifs_create_options(cifs_sb, create_options),
 312                 .disposition = disposition,
 313                 .path = full_path,
 314                 .fid = fid,
 315                 .mode = mode,
 316         };
 317         rc = server->ops->open(xid, &oparms, oplock, buf);
 318         if (rc) {
 319                 cifs_dbg(FYI, "cifs_create returned 0x%x\n", rc);
 320                 goto out;
 321         }
 322
 323 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 324         /*
 325          * If Open reported that we actually created a file then we now have to
 326          * set the mode if possible.
 327          */
 328         if ((tcon->unix_ext) && (*oplock & CIFS_CREATE_ACTION)) {
 329                 struct cifs_unix_set_info_args args = {
 330                                 .mode   = mode,
 331                                 .ctime  = NO_CHANGE_64,
 332                                 .atime  = NO_CHANGE_64,
 333                                 .mtime  = NO_CHANGE_64,
 334                                 .device = 0,
 335                 };
 336
 337                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
 338                         args.uid = current_fsuid();
 339                         if (inode->i_mode & S_ISGID)
 340                                 args.gid = inode->i_gid;
 341                         else
 342                                 args.gid = current_fsgid();
 343                 } else {
 344                         args.uid = INVALID_UID; /* no change */
 345                         args.gid = INVALID_GID; /* no change */
 346                 }
 347                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid->netfid,
 348                                        current->tgid);
 349         } else {
 350                 /*
 351                  * BB implement mode setting via Windows security
 352                  * descriptors e.g.
 353                  */
 354                 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
 355
 356                 /* Could set r/o dos attribute if mode & 0222 == 0 */
 357         }
 358
 359 cifs_create_get_file_info:
 360         /* server might mask mode so we have to query for it */
 361         if (tcon->unix_ext)
 362                 rc = cifs_get_inode_info_unix(&newinode, full_path, inode->i_sb,
 363                                               xid);
 364         else {
 365 #else
 366         {
 367 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 368                 /* TODO: Add support for calling POSIX query info here, but passing in fid */
 369                 rc = cifs_get_inode_info(&newinode, full_path, buf, inode->i_sb, xid, fid);
 370                 if (newinode) {
 371                         if (server->ops->set_lease_key)
 372                                 server->ops->set_lease_key(newinode, fid);
 373                         if ((*oplock & CIFS_CREATE_ACTION) && S_ISREG(newinode->i_mode)) {
 374                                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 375                                         newinode->i_mode = mode;
 376                                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
 377                                         newinode->i_uid = current_fsuid();
 378                                         if (inode->i_mode & S_ISGID)
 379                                                 newinode->i_gid = inode->i_gid;
 380                                         else
 381                                                 newinode->i_gid = current_fsgid();
 382                                 }
 383                         }
 384                 }
 385         }
 386
 387 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 388 cifs_create_set_dentry:
 389 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 390         if (rc != 0) {
 391                 cifs_dbg(FYI, "Create worked, get_inode_info failed rc = %d\n",
 392                          rc);
 393                 goto out_err;
 394         }
 395
 396         if (newinode)
 397                 if (S_ISDIR(newinode->i_mode)) {
 398                         rc = -EISDIR;
 399                         goto out_err;
 400                 }
 401
 402         d_drop(direntry);
 403         d_add(direntry, newinode);
 404
 405 out:
 406         free_dentry_path(page);
 407         return rc;
 408
 409 out_err:
 410         if (server->ops->close)
 411                 server->ops->close(xid, tcon, fid);
 412         if (newinode)
 413                 iput(newinode);
 414         goto out;
 415 }
 416
 417 int
 418 cifs_atomic_open(struct inode *inode, struct dentry *direntry,
 419                  struct file *file, unsigned oflags, umode_t mode)
 420 {
 421         int rc;
 422         unsigned int xid;
 423         struct tcon_link *tlink;
 424         struct cifs_tcon *tcon;
 425         struct TCP_Server_Info *server;
 426         struct cifs_fid fid = {};
 427         struct cifs_pending_open open;
 428         __u32 oplock;
 429         struct cifsFileInfo *file_info;
 430         struct cifs_open_info_data buf = {};
 431
 432         if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb))))
 433                 return -EIO;
 434
 435         /*
 436          * Posix open is only called (at lookup time) for file create now. For
 437          * opens (rather than creates), because we do not know if it is a file
 438          * or directory yet, and current Samba no longer allows us to do posix
 439          * open on dirs, we could end up wasting an open call on what turns out
 440          * to be a dir. For file opens, we wait to call posix open till
 441          * cifs_open.  It could be added to atomic_open in the future but the
 442          * performance tradeoff of the extra network request when EISDIR or
 443          * EACCES is returned would have to be weighed against the 50% reduction
 444          * in network traffic in the other paths.
 445          */
 446         if (!(oflags & O_CREAT)) {
 447                 struct dentry *res;
 448
 449                 /*
 450                  * Check for hashed negative dentry. We have already revalidated
 451                  * the dentry and it is fine. No need to perform another lookup.
 452                  */
 453                 if (!d_in_lookup(direntry))
 454                         return -ENOENT;
 455
 456                 res = cifs_lookup(inode, direntry, 0);
 457                 if (IS_ERR(res))
 458                         return PTR_ERR(res);
 459
 460                 return finish_no_open(file, res);
 461         }
 462
 463         xid = get_xid();
 464
 465         cifs_dbg(FYI, "parent inode = 0x%p name is: %pd and dentry = 0x%p\n",
 466                  inode, direntry, direntry);
 467
 468         tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb));
 469         if (IS_ERR(tlink)) {
 470                 rc = PTR_ERR(tlink);
 471                 goto out_free_xid;
 472         }
 473
 474         tcon = tlink_tcon(tlink);
 475
 476         rc = check_name(direntry, tcon);
 477         if (rc)
 478                 goto out;
 479
 480         server = tcon->ses->server;
 481
 482         if (server->ops->new_lease_key)
 483                 server->ops->new_lease_key(&fid);
 484
 485         cifs_add_pending_open(&fid, tlink, &open);
 486
 487         rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode,
 488                             &oplock, &fid, &buf);
 489         if (rc) {
 490                 cifs_del_pending_open(&open);
 491                 goto out;
 492         }
 493
 494         if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 495                 file->f_mode |= FMODE_CREATED;
 496
 497         rc = finish_open(file, direntry, generic_file_open);
 498         if (rc) {
 499                 if (server->ops->close)
 500                         server->ops->close(xid, tcon, &fid);
 501                 cifs_del_pending_open(&open);
 502                 goto out;
 503         }
 504
 505         if (file->f_flags & O_DIRECT &&
 506             CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
 507                 if (CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 508                         file->f_op = &cifs_file_direct_nobrl_ops;
 509                 else
 510                         file->f_op = &cifs_file_direct_ops;
 511                 }
 512
 513         file_info = cifs_new_fileinfo(&fid, file, tlink, oplock, buf.symlink_target);
 514         if (file_info == NULL) {
 515                 if (server->ops->close)
 516                         server->ops->close(xid, tcon, &fid);
 517                 cifs_del_pending_open(&open);
 518                 rc = -ENOMEM;
 519                 goto out;
 520         }
 521
 522         fscache_use_cookie(cifs_inode_cookie(file_inode(file)),
 523                            file->f_mode & FMODE_WRITE);
 524
 525 out:
 526         cifs_put_tlink(tlink);
 527 out_free_xid:
 528         free_xid(xid);
 529         cifs_free_open_info(&buf);
 530         return rc;
 531 }
 532
 533 int cifs_create(struct mnt_idmap *idmap, struct inode *inode,
 534                 struct dentry *direntry, umode_t mode, bool excl)
 535 {
 536         int rc;
 537         unsigned int xid = get_xid();
 538         /*
 539          * BB below access is probably too much for mknod to request
 540          *    but we have to do query and setpathinfo so requesting
 541          *    less could fail (unless we want to request getatr and setatr
 542          *    permissions (only).  At least for POSIX we do not have to
 543          *    request so much.
 544          */
 545         unsigned oflags = O_EXCL | O_CREAT | O_RDWR;
 546         struct tcon_link *tlink;
 547         struct cifs_tcon *tcon;
 548         struct TCP_Server_Info *server;
 549         struct cifs_fid fid;
 550         __u32 oplock;
 551         struct cifs_open_info_data buf = {};
 552
 553         cifs_dbg(FYI, "cifs_create parent inode = 0x%p name is: %pd and dentry = 0x%p\n",
 554                  inode, direntry, direntry);
 555
 556         if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb)))) {
 557                 rc = -EIO;
 558                 goto out_free_xid;
 559         }
 560
 561         tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb));
 562         rc = PTR_ERR(tlink);
 563         if (IS_ERR(tlink))
 564                 goto out_free_xid;
 565
 566         tcon = tlink_tcon(tlink);
 567         server = tcon->ses->server;
 568
 569         if (server->ops->new_lease_key)
 570                 server->ops->new_lease_key(&fid);
 571
 572         rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode, &oplock, &fid, &buf);
 573         if (!rc && server->ops->close)
 574                 server->ops->close(xid, tcon, &fid);
 575
 576         cifs_free_open_info(&buf);
 577         cifs_put_tlink(tlink);
 578 out_free_xid:
 579         free_xid(xid);
 580         return rc;
 581 }
 582
 583 int cifs_mknod(struct mnt_idmap *idmap, struct inode *inode,
 584                struct dentry *direntry, umode_t mode, dev_t device_number)
 585 {
 586         int rc = -EPERM;
 587         unsigned int xid;
 588         struct cifs_sb_info *cifs_sb;
 589         struct tcon_link *tlink;
 590         struct cifs_tcon *tcon;
 591         const char *full_path;
 592         void *page;
 593
 594         if (!old_valid_dev(device_number))
 595                 return -EINVAL;
 596
 597         cifs_sb = CIFS_SB(inode->i_sb);
 598         if (unlikely(cifs_forced_shutdown(cifs_sb)))
 599                 return -EIO;
 600
 601         tlink = cifs_sb_tlink(cifs_sb);
 602         if (IS_ERR(tlink))
 603                 return PTR_ERR(tlink);
 604
 605         page = alloc_dentry_path();
 606         tcon = tlink_tcon(tlink);
 607         xid = get_xid();
 608
 609         full_path = build_path_from_dentry(direntry, page);
 610         if (IS_ERR(full_path)) {
 611                 rc = PTR_ERR(full_path);
 612                 goto mknod_out;
 613         }
 614
 615         rc = tcon->ses->server->ops->make_node(xid, inode, direntry, tcon,
 616                                                full_path, mode,
 617                                                device_number);
 618
 619 mknod_out:
 620         free_dentry_path(page);
 621         free_xid(xid);
 622         cifs_put_tlink(tlink);
 623         return rc;
 624 }
 625
 626 struct dentry *
 627 cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
 628             unsigned int flags)
 629 {
 630         unsigned int xid;
 631         int rc = 0; /* to get around spurious gcc warning, set to zero here */
 632         struct cifs_sb_info *cifs_sb;
 633         struct tcon_link *tlink;
 634         struct cifs_tcon *pTcon;
 635         struct inode *newInode = NULL;
 636         const char *full_path;
 637         void *page;
 638         int retry_count = 0;
 639
 640         xid = get_xid();
 641
 642         cifs_dbg(FYI, "parent inode = 0x%p name is: %pd and dentry = 0x%p\n",
 643                  parent_dir_inode, direntry, direntry);
 644
 645         /* check whether path exists */
 646
 647         cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
 648         tlink = cifs_sb_tlink(cifs_sb);
 649         if (IS_ERR(tlink)) {
 650                 free_xid(xid);
 651                 return ERR_CAST(tlink);
 652         }
 653         pTcon = tlink_tcon(tlink);
 654
 655         rc = check_name(direntry, pTcon);
 656         if (unlikely(rc)) {
 657                 cifs_put_tlink(tlink);
 658                 free_xid(xid);
 659                 return ERR_PTR(rc);
 660         }
 661
 662         /* can not grab the rename sem here since it would
 663         deadlock in the cases (beginning of sys_rename itself)
 664         in which we already have the sb rename sem */
 665         page = alloc_dentry_path();
 666         full_path = build_path_from_dentry(direntry, page);
 667         if (IS_ERR(full_path)) {
 668                 cifs_put_tlink(tlink);
 669                 free_xid(xid);
 670                 free_dentry_path(page);
 671                 return ERR_CAST(full_path);
 672         }
 673
 674         if (d_really_is_positive(direntry)) {
 675                 cifs_dbg(FYI, "non-NULL inode in lookup\n");
 676         } else {
 677                 cifs_dbg(FYI, "NULL inode in lookup\n");
 678         }
 679         cifs_dbg(FYI, "Full path: %s inode = 0x%p\n",
 680                  full_path, d_inode(direntry));
 681
 682 again:
 683         if (pTcon->posix_extensions) {
 684                 rc = smb311_posix_get_inode_info(&newInode, full_path, NULL,
 685                                                  parent_dir_inode->i_sb, xid);
 686         } else if (pTcon->unix_ext) {
 687                 rc = cifs_get_inode_info_unix(&newInode, full_path,
 688                                               parent_dir_inode->i_sb, xid);
 689         } else {
 690                 rc = cifs_get_inode_info(&newInode, full_path, NULL,
 691                                 parent_dir_inode->i_sb, xid, NULL);
 692         }
 693
 694         if (rc == 0) {
 695                 /* since paths are not looked up by component - the parent
 696                    directories are presumed to be good here */
 697                 renew_parental_timestamps(direntry);
 698         } else if (rc == -EAGAIN && retry_count++ < 10) {
 699                 goto again;
 700         } else if (rc == -ENOENT) {
 701                 cifs_set_time(direntry, jiffies);
 702                 newInode = NULL;
 703         } else {
 704                 if (rc != -EACCES) {
 705                         cifs_dbg(FYI, "Unexpected lookup error %d\n", rc);
 706                         /* We special case check for Access Denied - since that
 707                         is a common return code */
 708                 }
 709                 newInode = ERR_PTR(rc);
 710         }
 711         free_dentry_path(page);
 712         cifs_put_tlink(tlink);
 713         free_xid(xid);
 714         return d_splice_alias(newInode, direntry);
 715 }
 716
 717 static int
 718 cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
 719 {
 720         struct inode *inode;
 721         int rc;
 722
 723         if (flags & LOOKUP_RCU)
 724                 return -ECHILD;
 725
 726         if (d_really_is_positive(direntry)) {
 727                 inode = d_inode(direntry);
 728                 if ((flags & LOOKUP_REVAL) && !CIFS_CACHE_READ(CIFS_I(inode)))
 729                         CIFS_I(inode)->time = 0; /* force reval */
 730
 731                 rc = cifs_revalidate_dentry(direntry);
 732                 if (rc) {
 733                         cifs_dbg(FYI, "cifs_revalidate_dentry failed with rc=%d", rc);
 734                         switch (rc) {
 735                         case -ENOENT:
 736                         case -ESTALE:
 737                                 /*
 738                                  * Those errors mean the dentry is invalid
 739                                  * (file was deleted or recreated)
 740                                  */
 741                                 return 0;
 742                         default:
 743                                 /*
 744                                  * Otherwise some unexpected error happened
 745                                  * report it as-is to VFS layer
 746                                  */
 747                                 return rc;
 748                         }
 749                 }
 750                 else {
 751                         /*
 752                          * If the inode wasn't known to be a dfs entry when
 753                          * the dentry was instantiated, such as when created
 754                          * via ->readdir(), it needs to be set now since the
 755                          * attributes will have been updated by
 756                          * cifs_revalidate_dentry().
 757                          */
 758                         if (IS_AUTOMOUNT(inode) &&
 759                            !(direntry->d_flags & DCACHE_NEED_AUTOMOUNT)) {
 760                                 spin_lock(&direntry->d_lock);
 761                                 direntry->d_flags |= DCACHE_NEED_AUTOMOUNT;
 762                                 spin_unlock(&direntry->d_lock);
 763                         }
 764
 765                         return 1;
 766                 }
 767         }
 768
 769         /*
 770          * This may be nfsd (or something), anyway, we can't see the
 771          * intent of this. So, since this can be for creation, drop it.
 772          */
 773         if (!flags)
 774                 return 0;
 775
 776         /*
 777          * Drop the negative dentry, in order to make sure to use the
 778          * case sensitive name which is specified by user if this is
 779          * for creation.
 780          */
 781         if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
 782                 return 0;
 783
 784         if (time_after(jiffies, cifs_get_time(direntry) + HZ) || !lookupCacheEnabled)
 785                 return 0;
 786
 787         return 1;
 788 }
 789
 790 /* static int cifs_d_delete(struct dentry *direntry)
 791 {
 792         int rc = 0;
 793
 794         cifs_dbg(FYI, "In cifs d_delete, name = %pd\n", direntry);
 795
 796         return rc;
 797 }     */
 798
 799 const struct dentry_operations cifs_dentry_ops = {
 800         .d_revalidate = cifs_d_revalidate,
 801         .d_automount = cifs_d_automount,
 802 /* d_delete:       cifs_d_delete,      */ /* not needed except for debugging */
 803 };
 804
 805 static int cifs_ci_hash(const struct dentry *dentry, struct qstr *q)
 806 {
 807         struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
 808         unsigned long hash;
 809         wchar_t c;
 810         int i, charlen;
 811
 812         hash = init_name_hash(dentry);
 813         for (i = 0; i < q->len; i += charlen) {
 814                 charlen = codepage->char2uni(&q->name[i], q->len - i, &c);
 815                 /* error out if we can't convert the character */
 816                 if (unlikely(charlen < 0))
 817                         return charlen;
 818                 hash = partial_name_hash(cifs_toupper(c), hash);
 819         }
 820         q->hash = end_name_hash(hash);
 821
 822         return 0;
 823 }
 824
 825 static int cifs_ci_compare(const struct dentry *dentry,
 826                 unsigned int len, const char *str, const struct qstr *name)
 827 {
 828         struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
 829         wchar_t c1, c2;
 830         int i, l1, l2;
 831
 832         /*
 833          * We make the assumption here that uppercase characters in the local
 834          * codepage are always the same length as their lowercase counterparts.
 835          *
 836          * If that's ever not the case, then this will fail to match it.
 837          */
 838         if (name->len != len)
 839                 return 1;
 840
 841         for (i = 0; i < len; i += l1) {
 842                 /* Convert characters in both strings to UTF-16. */
 843                 l1 = codepage->char2uni(&str[i], len - i, &c1);
 844                 l2 = codepage->char2uni(&name->name[i], name->len - i, &c2);
 845
 846                 /*
 847                  * If we can't convert either character, just declare it to
 848                  * be 1 byte long and compare the original byte.
 849                  */
 850                 if (unlikely(l1 < 0 && l2 < 0)) {
 851                         if (str[i] != name->name[i])
 852                                 return 1;
 853                         l1 = 1;
 854                         continue;
 855                 }
 856
 857                 /*
 858                  * Here, we again ass|u|me that upper/lowercase versions of
 859                  * a character are the same length in the local NLS.
 860                  */
 861                 if (l1 != l2)
 862                         return 1;
 863
 864                 /* Now compare uppercase versions of these characters */
 865                 if (cifs_toupper(c1) != cifs_toupper(c2))
 866                         return 1;
 867         }
 868
 869         return 0;
 870 }
 871
 872 const struct dentry_operations cifs_ci_dentry_ops = {
 873         .d_revalidate = cifs_d_revalidate,
 874         .d_hash = cifs_ci_hash,
 875         .d_compare = cifs_ci_compare,
 876         .d_automount = cifs_d_automount,
 877 };