fs/cifs/dir.c

   1 /*
   2  *   fs/cifs/dir.c
   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  *   This library is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU Lesser General Public License as published
  11  *   by the Free Software Foundation; either version 2.1 of the License, or
  12  *   (at your option) any later version.
  13  *
  14  *   This library is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  17  *   the GNU Lesser General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU Lesser General Public License
  20  *   along with this library; if not, write to the Free Software
  21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22  */
  23 #include <linux/fs.h>
  24 #include <linux/stat.h>
  25 #include <linux/slab.h>
  26 #include <linux/namei.h>
  27 #include <linux/mount.h>
  28 #include <linux/file.h>
  29 #include "cifsfs.h"
  30 #include "cifspdu.h"
  31 #include "cifsglob.h"
  32 #include "cifsproto.h"
  33 #include "cifs_debug.h"
  34 #include "cifs_fs_sb.h"
  35
  36 static void
  37 renew_parental_timestamps(struct dentry *direntry)
  38 {
  39         /* BB check if there is a way to get the kernel to do this or if we
  40            really need this */
  41         do {
  42                 direntry->d_time = jiffies;
  43                 direntry = direntry->d_parent;
  44         } while (!IS_ROOT(direntry));
  45 }
  46
  47 /* Note: caller must free return buffer */
  48 char *
  49 build_path_from_dentry(struct dentry *direntry)
  50 {
  51         struct dentry *temp;
  52         int namelen;
  53         int dfsplen;
  54         char *full_path;
  55         char dirsep;
  56         struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
  57         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
  58         unsigned seq;
  59
  60         dirsep = CIFS_DIR_SEP(cifs_sb);
  61         if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
  62                 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
  63         else
  64                 dfsplen = 0;
  65 cifs_bp_rename_retry:
  66         namelen = dfsplen;
  67         seq = read_seqbegin(&rename_lock);
  68         rcu_read_lock();
  69         for (temp = direntry; !IS_ROOT(temp);) {
  70                 namelen += (1 + temp->d_name.len);
  71                 temp = temp->d_parent;
  72                 if (temp == NULL) {
  73                         cERROR(1, "corrupt dentry");
  74                         rcu_read_unlock();
  75                         return NULL;
  76                 }
  77         }
  78         rcu_read_unlock();
  79
  80         full_path = kmalloc(namelen+1, GFP_KERNEL);
  81         if (full_path == NULL)
  82                 return full_path;
  83         full_path[namelen] = 0; /* trailing null */
  84         rcu_read_lock();
  85         for (temp = direntry; !IS_ROOT(temp);) {
  86                 spin_lock(&temp->d_lock);
  87                 namelen -= 1 + temp->d_name.len;
  88                 if (namelen < 0) {
  89                         spin_unlock(&temp->d_lock);
  90                         break;
  91                 } else {
  92                         full_path[namelen] = dirsep;
  93                         strncpy(full_path + namelen + 1, temp->d_name.name,
  94                                 temp->d_name.len);
  95                         cFYI(0, "name: %s", full_path + namelen);
  96                 }
  97                 spin_unlock(&temp->d_lock);
  98                 temp = temp->d_parent;
  99                 if (temp == NULL) {
 100                         cERROR(1, "corrupt dentry");
 101                         rcu_read_unlock();
 102                         kfree(full_path);
 103                         return NULL;
 104                 }
 105         }
 106         rcu_read_unlock();
 107         if (namelen != dfsplen || read_seqretry(&rename_lock, seq)) {
 108                 cFYI(1, "did not end path lookup where expected. namelen=%d "
 109                         "dfsplen=%d", namelen, dfsplen);
 110                 /* presumably this is only possible if racing with a rename
 111                 of one of the parent directories  (we can not lock the dentries
 112                 above us to prevent this, but retrying should be harmless) */
 113                 kfree(full_path);
 114                 goto cifs_bp_rename_retry;
 115         }
 116         /* DIR_SEP already set for byte  0 / vs \ but not for
 117            subsequent slashes in prepath which currently must
 118            be entered the right way - not sure if there is an alternative
 119            since the '\' is a valid posix character so we can not switch
 120            those safely to '/' if any are found in the middle of the prepath */
 121         /* BB test paths to Windows with '/' in the midst of prepath */
 122
 123         if (dfsplen) {
 124                 strncpy(full_path, tcon->treeName, dfsplen);
 125                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
 126                         int i;
 127                         for (i = 0; i < dfsplen; i++) {
 128                                 if (full_path[i] == '\\')
 129                                         full_path[i] = '/';
 130                         }
 131                 }
 132         }
 133         return full_path;
 134 }
 135
 136 /* Inode operations in similar order to how they appear in Linux file fs.h */
 137
 138 int
 139 cifs_create(struct inode *inode, struct dentry *direntry, int mode,
 140                 struct nameidata *nd)
 141 {
 142         int rc = -ENOENT;
 143         int xid;
 144         int create_options = CREATE_NOT_DIR;
 145         __u32 oplock = 0;
 146         int oflags;
 147         /*
 148          * BB below access is probably too much for mknod to request
 149          *    but we have to do query and setpathinfo so requesting
 150          *    less could fail (unless we want to request getatr and setatr
 151          *    permissions (only).  At least for POSIX we do not have to
 152          *    request so much.
 153          */
 154         int desiredAccess = GENERIC_READ | GENERIC_WRITE;
 155         __u16 fileHandle;
 156         struct cifs_sb_info *cifs_sb;
 157         struct tcon_link *tlink;
 158         struct cifs_tcon *tcon;
 159         char *full_path = NULL;
 160         FILE_ALL_INFO *buf = NULL;
 161         struct inode *newinode = NULL;
 162         int disposition = FILE_OVERWRITE_IF;
 163
 164         xid = GetXid();
 165
 166         cifs_sb = CIFS_SB(inode->i_sb);
 167         tlink = cifs_sb_tlink(cifs_sb);
 168         if (IS_ERR(tlink)) {
 169                 FreeXid(xid);
 170                 return PTR_ERR(tlink);
 171         }
 172         tcon = tlink_tcon(tlink);
 173
 174         if (oplockEnabled)
 175                 oplock = REQ_OPLOCK;
 176
 177         if (nd)
 178                 oflags = nd->intent.open.file->f_flags;
 179         else
 180                 oflags = O_RDONLY | O_CREAT;
 181
 182         full_path = build_path_from_dentry(direntry);
 183         if (full_path == NULL) {
 184                 rc = -ENOMEM;
 185                 goto cifs_create_out;
 186         }
 187
 188         if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
 189             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 190                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 191                 rc = cifs_posix_open(full_path, &newinode,
 192                         inode->i_sb, mode, oflags, &oplock, &fileHandle, xid);
 193                 /* EIO could indicate that (posix open) operation is not
 194                    supported, despite what server claimed in capability
 195                    negotiation.  EREMOTE indicates DFS junction, which is not
 196                    handled in posix open */
 197
 198                 if (rc == 0) {
 199                         if (newinode == NULL) /* query inode info */
 200                                 goto cifs_create_get_file_info;
 201                         else /* success, no need to query */
 202                                 goto cifs_create_set_dentry;
 203                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
 204                          (rc != -EOPNOTSUPP) && (rc != -EINVAL))
 205                         goto cifs_create_out;
 206                 /* else fallthrough to retry, using older open call, this is
 207                    case where server does not support this SMB level, and
 208                    falsely claims capability (also get here for DFS case
 209                    which should be rare for path not covered on files) */
 210         }
 211
 212         if (nd) {
 213                 /* if the file is going to stay open, then we
 214                    need to set the desired access properly */
 215                 desiredAccess = 0;
 216                 if (OPEN_FMODE(oflags) & FMODE_READ)
 217                         desiredAccess |= GENERIC_READ; /* is this too little? */
 218                 if (OPEN_FMODE(oflags) & FMODE_WRITE)
 219                         desiredAccess |= GENERIC_WRITE;
 220
 221                 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 222                         disposition = FILE_CREATE;
 223                 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
 224                         disposition = FILE_OVERWRITE_IF;
 225                 else if ((oflags & O_CREAT) == O_CREAT)
 226                         disposition = FILE_OPEN_IF;
 227                 else
 228                         cFYI(1, "Create flag not set in create function");
 229         }
 230
 231         /* BB add processing to set equivalent of mode - e.g. via CreateX with
 232            ACLs */
 233
 234         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 235         if (buf == NULL) {
 236                 rc = -ENOMEM;
 237                 goto cifs_create_out;
 238         }
 239
 240         /*
 241          * if we're not using unix extensions, see if we need to set
 242          * ATTR_READONLY on the create call
 243          */
 244         if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
 245                 create_options |= CREATE_OPTION_READONLY;
 246
 247         if (tcon->ses->capabilities & CAP_NT_SMBS)
 248                 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
 249                          desiredAccess, create_options,
 250                          &fileHandle, &oplock, buf, cifs_sb->local_nls,
 251                          cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 252         else
 253                 rc = -EIO; /* no NT SMB support fall into legacy open below */
 254
 255         if (rc == -EIO) {
 256                 /* old server, retry the open legacy style */
 257                 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
 258                         desiredAccess, create_options,
 259                         &fileHandle, &oplock, buf, cifs_sb->local_nls,
 260                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 261         }
 262         if (rc) {
 263                 cFYI(1, "cifs_create returned 0x%x", rc);
 264                 goto cifs_create_out;
 265         }
 266
 267         /* If Open reported that we actually created a file
 268            then we now have to set the mode if possible */
 269         if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
 270                 struct cifs_unix_set_info_args args = {
 271                                 .mode   = mode,
 272                                 .ctime  = NO_CHANGE_64,
 273                                 .atime  = NO_CHANGE_64,
 274                                 .mtime  = NO_CHANGE_64,
 275                                 .device = 0,
 276                 };
 277
 278                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
 279                         args.uid = (__u64) current_fsuid();
 280                         if (inode->i_mode & S_ISGID)
 281                                 args.gid = (__u64) inode->i_gid;
 282                         else
 283                                 args.gid = (__u64) current_fsgid();
 284                 } else {
 285                         args.uid = NO_CHANGE_64;
 286                         args.gid = NO_CHANGE_64;
 287                 }
 288                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fileHandle,
 289                                         current->tgid);
 290         } else {
 291                 /* BB implement mode setting via Windows security
 292                    descriptors e.g. */
 293                 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
 294
 295                 /* Could set r/o dos attribute if mode & 0222 == 0 */
 296         }
 297
 298 cifs_create_get_file_info:
 299         /* server might mask mode so we have to query for it */
 300         if (tcon->unix_ext)
 301                 rc = cifs_get_inode_info_unix(&newinode, full_path,
 302                                               inode->i_sb, xid);
 303         else {
 304                 rc = cifs_get_inode_info(&newinode, full_path, buf,
 305                                          inode->i_sb, xid, &fileHandle);
 306                 if (newinode) {
 307                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 308                                 newinode->i_mode = mode;
 309                         if ((oplock & CIFS_CREATE_ACTION) &&
 310                             (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
 311                                 newinode->i_uid = current_fsuid();
 312                                 if (inode->i_mode & S_ISGID)
 313                                         newinode->i_gid = inode->i_gid;
 314                                 else
 315                                         newinode->i_gid = current_fsgid();
 316                         }
 317                 }
 318         }
 319
 320 cifs_create_set_dentry:
 321         if (rc == 0)
 322                 d_instantiate(direntry, newinode);
 323         else
 324                 cFYI(1, "Create worked, get_inode_info failed rc = %d", rc);
 325
 326         if (newinode && nd) {
 327                 struct cifsFileInfo *pfile_info;
 328                 struct file *filp;
 329
 330                 filp = lookup_instantiate_filp(nd, direntry, generic_file_open);
 331                 if (IS_ERR(filp)) {
 332                         rc = PTR_ERR(filp);
 333                         CIFSSMBClose(xid, tcon, fileHandle);
 334                         goto cifs_create_out;
 335                 }
 336
 337                 pfile_info = cifs_new_fileinfo(fileHandle, filp, tlink, oplock);
 338                 if (pfile_info == NULL) {
 339                         fput(filp);
 340                         CIFSSMBClose(xid, tcon, fileHandle);
 341                         rc = -ENOMEM;
 342                 }
 343         } else {
 344                 CIFSSMBClose(xid, tcon, fileHandle);
 345         }
 346
 347 cifs_create_out:
 348         kfree(buf);
 349         kfree(full_path);
 350         cifs_put_tlink(tlink);
 351         FreeXid(xid);
 352         return rc;
 353 }
 354
 355 int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
 356                 dev_t device_number)
 357 {
 358         int rc = -EPERM;
 359         int xid;
 360         struct cifs_sb_info *cifs_sb;
 361         struct tcon_link *tlink;
 362         struct cifs_tcon *pTcon;
 363         struct cifs_io_parms io_parms;
 364         char *full_path = NULL;
 365         struct inode *newinode = NULL;
 366         int oplock = 0;
 367         u16 fileHandle;
 368         FILE_ALL_INFO *buf = NULL;
 369         unsigned int bytes_written;
 370         struct win_dev *pdev;
 371
 372         if (!old_valid_dev(device_number))
 373                 return -EINVAL;
 374
 375         cifs_sb = CIFS_SB(inode->i_sb);
 376         tlink = cifs_sb_tlink(cifs_sb);
 377         if (IS_ERR(tlink))
 378                 return PTR_ERR(tlink);
 379
 380         pTcon = tlink_tcon(tlink);
 381
 382         xid = GetXid();
 383
 384         full_path = build_path_from_dentry(direntry);
 385         if (full_path == NULL) {
 386                 rc = -ENOMEM;
 387                 goto mknod_out;
 388         }
 389
 390         if (pTcon->unix_ext) {
 391                 struct cifs_unix_set_info_args args = {
 392                         .mode   = mode & ~current_umask(),
 393                         .ctime  = NO_CHANGE_64,
 394                         .atime  = NO_CHANGE_64,
 395                         .mtime  = NO_CHANGE_64,
 396                         .device = device_number,
 397                 };
 398                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
 399                         args.uid = (__u64) current_fsuid();
 400                         args.gid = (__u64) current_fsgid();
 401                 } else {
 402                         args.uid = NO_CHANGE_64;
 403                         args.gid = NO_CHANGE_64;
 404                 }
 405                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
 406                                             cifs_sb->local_nls,
 407                                             cifs_sb->mnt_cifs_flags &
 408                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 409                 if (rc)
 410                         goto mknod_out;
 411
 412                 rc = cifs_get_inode_info_unix(&newinode, full_path,
 413                                                 inode->i_sb, xid);
 414
 415                 if (rc == 0)
 416                         d_instantiate(direntry, newinode);
 417                 goto mknod_out;
 418         }
 419
 420         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
 421                 goto mknod_out;
 422
 423
 424         cFYI(1, "sfu compat create special file");
 425
 426         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 427         if (buf == NULL) {
 428                 kfree(full_path);
 429                 rc = -ENOMEM;
 430                 FreeXid(xid);
 431                 return rc;
 432         }
 433
 434         /* FIXME: would WRITE_OWNER | WRITE_DAC be better? */
 435         rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_CREATE,
 436                          GENERIC_WRITE, CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,
 437                          &fileHandle, &oplock, buf, cifs_sb->local_nls,
 438                          cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 439         if (rc)
 440                 goto mknod_out;
 441
 442         /* BB Do not bother to decode buf since no local inode yet to put
 443          * timestamps in, but we can reuse it safely */
 444
 445         pdev = (struct win_dev *)buf;
 446         io_parms.netfid = fileHandle;
 447         io_parms.pid = current->tgid;
 448         io_parms.tcon = pTcon;
 449         io_parms.offset = 0;
 450         io_parms.length = sizeof(struct win_dev);
 451         if (S_ISCHR(mode)) {
 452                 memcpy(pdev->type, "IntxCHR", 8);
 453                 pdev->major =
 454                       cpu_to_le64(MAJOR(device_number));
 455                 pdev->minor =
 456                       cpu_to_le64(MINOR(device_number));
 457                 rc = CIFSSMBWrite(xid, &io_parms,
 458                         &bytes_written, (char *)pdev,
 459                         NULL, 0);
 460         } else if (S_ISBLK(mode)) {
 461                 memcpy(pdev->type, "IntxBLK", 8);
 462                 pdev->major =
 463                       cpu_to_le64(MAJOR(device_number));
 464                 pdev->minor =
 465                       cpu_to_le64(MINOR(device_number));
 466                 rc = CIFSSMBWrite(xid, &io_parms,
 467                         &bytes_written, (char *)pdev,
 468                         NULL, 0);
 469         } /* else if (S_ISFIFO) */
 470         CIFSSMBClose(xid, pTcon, fileHandle);
 471         d_drop(direntry);
 472
 473         /* FIXME: add code here to set EAs */
 474
 475 mknod_out:
 476         kfree(full_path);
 477         kfree(buf);
 478         FreeXid(xid);
 479         cifs_put_tlink(tlink);
 480         return rc;
 481 }
 482
 483 struct dentry *
 484 cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
 485             struct nameidata *nd)
 486 {
 487         int xid;
 488         int rc = 0; /* to get around spurious gcc warning, set to zero here */
 489         __u32 oplock = 0;
 490         __u16 fileHandle = 0;
 491         bool posix_open = false;
 492         struct cifs_sb_info *cifs_sb;
 493         struct tcon_link *tlink;
 494         struct cifs_tcon *pTcon;
 495         struct cifsFileInfo *cfile;
 496         struct inode *newInode = NULL;
 497         char *full_path = NULL;
 498         struct file *filp;
 499
 500         xid = GetXid();
 501
 502         cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
 503               parent_dir_inode, direntry->d_name.name, direntry);
 504
 505         /* check whether path exists */
 506
 507         cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
 508         tlink = cifs_sb_tlink(cifs_sb);
 509         if (IS_ERR(tlink)) {
 510                 FreeXid(xid);
 511                 return (struct dentry *)tlink;
 512         }
 513         pTcon = tlink_tcon(tlink);
 514
 515         /*
 516          * Don't allow the separator character in a path component.
 517          * The VFS will not allow "/", but "\" is allowed by posix.
 518          */
 519         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
 520                 int i;
 521                 for (i = 0; i < direntry->d_name.len; i++)
 522                         if (direntry->d_name.name[i] == '\\') {
 523                                 cFYI(1, "Invalid file name");
 524                                 rc = -EINVAL;
 525                                 goto lookup_out;
 526                         }
 527         }
 528
 529         /*
 530          * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
 531          * the VFS handle the create.
 532          */
 533         if (nd && (nd->flags & LOOKUP_EXCL)) {
 534                 d_instantiate(direntry, NULL);
 535                 rc = 0;
 536                 goto lookup_out;
 537         }
 538
 539         /* can not grab the rename sem here since it would
 540         deadlock in the cases (beginning of sys_rename itself)
 541         in which we already have the sb rename sem */
 542         full_path = build_path_from_dentry(direntry);
 543         if (full_path == NULL) {
 544                 rc = -ENOMEM;
 545                 goto lookup_out;
 546         }
 547
 548         if (direntry->d_inode != NULL) {
 549                 cFYI(1, "non-NULL inode in lookup");
 550         } else {
 551                 cFYI(1, "NULL inode in lookup");
 552         }
 553         cFYI(1, "Full path: %s inode = 0x%p", full_path, direntry->d_inode);
 554
 555         /* Posix open is only called (at lookup time) for file create now.
 556          * For opens (rather than creates), because we do not know if it
 557          * is a file or directory yet, and current Samba no longer allows
 558          * us to do posix open on dirs, we could end up wasting an open call
 559          * on what turns out to be a dir. For file opens, we wait to call posix
 560          * open till cifs_open.  It could be added here (lookup) in the future
 561          * but the performance tradeoff of the extra network request when EISDIR
 562          * or EACCES is returned would have to be weighed against the 50%
 563          * reduction in network traffic in the other paths.
 564          */
 565         if (pTcon->unix_ext) {
 566                 if (nd && !(nd->flags & LOOKUP_DIRECTORY) &&
 567                      (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
 568                      (nd->intent.open.file->f_flags & O_CREAT)) {
 569                         rc = cifs_posix_open(full_path, &newInode,
 570                                         parent_dir_inode->i_sb,
 571                                         nd->intent.open.create_mode,
 572                                         nd->intent.open.file->f_flags, &oplock,
 573                                         &fileHandle, xid);
 574                         /*
 575                          * The check below works around a bug in POSIX
 576                          * open in samba versions 3.3.1 and earlier where
 577                          * open could incorrectly fail with invalid parameter.
 578                          * If either that or op not supported returned, follow
 579                          * the normal lookup.
 580                          */
 581                         if ((rc == 0) || (rc == -ENOENT))
 582                                 posix_open = true;
 583                         else if ((rc == -EINVAL) || (rc != -EOPNOTSUPP))
 584                                 pTcon->broken_posix_open = true;
 585                 }
 586                 if (!posix_open)
 587                         rc = cifs_get_inode_info_unix(&newInode, full_path,
 588                                                 parent_dir_inode->i_sb, xid);
 589         } else
 590                 rc = cifs_get_inode_info(&newInode, full_path, NULL,
 591                                 parent_dir_inode->i_sb, xid, NULL);
 592
 593         if ((rc == 0) && (newInode != NULL)) {
 594                 d_add(direntry, newInode);
 595                 if (posix_open) {
 596                         filp = lookup_instantiate_filp(nd, direntry,
 597                                                        generic_file_open);
 598                         if (IS_ERR(filp)) {
 599                                 rc = PTR_ERR(filp);
 600                                 CIFSSMBClose(xid, pTcon, fileHandle);
 601                                 goto lookup_out;
 602                         }
 603
 604                         cfile = cifs_new_fileinfo(fileHandle, filp, tlink,
 605                                                   oplock);
 606                         if (cfile == NULL) {
 607                                 fput(filp);
 608                                 CIFSSMBClose(xid, pTcon, fileHandle);
 609                                 rc = -ENOMEM;
 610                                 goto lookup_out;
 611                         }
 612                 }
 613                 /* since paths are not looked up by component - the parent
 614                    directories are presumed to be good here */
 615                 renew_parental_timestamps(direntry);
 616
 617         } else if (rc == -ENOENT) {
 618                 rc = 0;
 619                 direntry->d_time = jiffies;
 620                 d_add(direntry, NULL);
 621         /*      if it was once a directory (but how can we tell?) we could do
 622                 shrink_dcache_parent(direntry); */
 623         } else if (rc != -EACCES) {
 624                 cERROR(1, "Unexpected lookup error %d", rc);
 625                 /* We special case check for Access Denied - since that
 626                 is a common return code */
 627         }
 628
 629 lookup_out:
 630         kfree(full_path);
 631         cifs_put_tlink(tlink);
 632         FreeXid(xid);
 633         return ERR_PTR(rc);
 634 }
 635
 636 static int
 637 cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
 638 {
 639         if (nd && (nd->flags & LOOKUP_RCU))
 640                 return -ECHILD;
 641
 642         if (direntry->d_inode) {
 643                 if (cifs_revalidate_dentry(direntry))
 644                         return 0;
 645                 else
 646                         return 1;
 647         }
 648
 649         /*
 650          * This may be nfsd (or something), anyway, we can't see the
 651          * intent of this. So, since this can be for creation, drop it.
 652          */
 653         if (!nd)
 654                 return 0;
 655
 656         /*
 657          * Drop the negative dentry, in order to make sure to use the
 658          * case sensitive name which is specified by user if this is
 659          * for creation.
 660          */
 661         if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
 662                 return 0;
 663
 664         if (time_after(jiffies, direntry->d_time + HZ) || !lookupCacheEnabled)
 665                 return 0;
 666
 667         return 1;
 668 }
 669
 670 /* static int cifs_d_delete(struct dentry *direntry)
 671 {
 672         int rc = 0;
 673
 674         cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
 675
 676         return rc;
 677 }     */
 678
 679 const struct dentry_operations cifs_dentry_ops = {
 680         .d_revalidate = cifs_d_revalidate,
 681         .d_automount = cifs_dfs_d_automount,
 682 /* d_delete:       cifs_d_delete,      */ /* not needed except for debugging */
 683 };
 684
 685 static int cifs_ci_hash(const struct dentry *dentry, const struct inode *inode,
 686                 struct qstr *q)
 687 {
 688         struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
 689         unsigned long hash;
 690         int i;
 691
 692         hash = init_name_hash();
 693         for (i = 0; i < q->len; i++)
 694                 hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
 695                                          hash);
 696         q->hash = end_name_hash(hash);
 697
 698         return 0;
 699 }
 700
 701 static int cifs_ci_compare(const struct dentry *parent,
 702                 const struct inode *pinode,
 703                 const struct dentry *dentry, const struct inode *inode,
 704                 unsigned int len, const char *str, const struct qstr *name)
 705 {
 706         struct nls_table *codepage = CIFS_SB(pinode->i_sb)->local_nls;
 707
 708         if ((name->len == len) &&
 709             (nls_strnicmp(codepage, name->name, str, len) == 0))
 710                 return 0;
 711         return 1;
 712 }
 713
 714 const struct dentry_operations cifs_ci_dentry_ops = {
 715         .d_revalidate = cifs_d_revalidate,
 716         .d_hash = cifs_ci_hash,
 717         .d_compare = cifs_ci_compare,
 718         .d_automount = cifs_dfs_d_automount,
 719 };