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 "cifsfs.h"
  29 #include "cifspdu.h"
  30 #include "cifsglob.h"
  31 #include "cifsproto.h"
  32 #include "cifs_debug.h"
  33 #include "cifs_fs_sb.h"
  34
  35 static void
  36 renew_parental_timestamps(struct dentry *direntry)
  37 {
  38         /* BB check if there is a way to get the kernel to do this or if we
  39            really need this */
  40         do {
  41                 direntry->d_time = jiffies;
  42                 direntry = direntry->d_parent;
  43         } while (!IS_ROOT(direntry));
  44 }
  45
  46 /* Note: caller must free return buffer */
  47 char *
  48 build_path_from_dentry(struct dentry *direntry)
  49 {
  50         struct dentry *temp;
  51         int namelen;
  52         int pplen;
  53         int dfsplen;
  54         char *full_path;
  55         char dirsep;
  56         struct cifs_sb_info *cifs_sb;
  57
  58         if (direntry == NULL)
  59                 return NULL;  /* not much we can do if dentry is freed and
  60                 we need to reopen the file after it was closed implicitly
  61                 when the server crashed */
  62
  63         cifs_sb = CIFS_SB(direntry->d_sb);
  64         dirsep = CIFS_DIR_SEP(cifs_sb);
  65         pplen = cifs_sb->prepathlen;
  66         if (cifs_sb->tcon && (cifs_sb->tcon->Flags & SMB_SHARE_IS_IN_DFS))
  67                 dfsplen = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE + 1);
  68         else
  69                 dfsplen = 0;
  70 cifs_bp_rename_retry:
  71         namelen = pplen + dfsplen;
  72         for (temp = direntry; !IS_ROOT(temp);) {
  73                 namelen += (1 + temp->d_name.len);
  74                 temp = temp->d_parent;
  75                 if (temp == NULL) {
  76                         cERROR(1, ("corrupt dentry"));
  77                         return NULL;
  78                 }
  79         }
  80
  81         full_path = kmalloc(namelen+1, GFP_KERNEL);
  82         if (full_path == NULL)
  83                 return full_path;
  84         full_path[namelen] = 0; /* trailing null */
  85         for (temp = direntry; !IS_ROOT(temp);) {
  86                 namelen -= 1 + temp->d_name.len;
  87                 if (namelen < 0) {
  88                         break;
  89                 } else {
  90                         full_path[namelen] = dirsep;
  91                         strncpy(full_path + namelen + 1, temp->d_name.name,
  92                                 temp->d_name.len);
  93                         cFYI(0, ("name: %s", full_path + namelen));
  94                 }
  95                 temp = temp->d_parent;
  96                 if (temp == NULL) {
  97                         cERROR(1, ("corrupt dentry"));
  98                         kfree(full_path);
  99                         return NULL;
 100                 }
 101         }
 102         if (namelen != pplen + dfsplen) {
 103                 cERROR(1,
 104                        ("did not end path lookup where expected namelen is %d",
 105                         namelen));
 106                 /* presumably this is only possible if racing with a rename
 107                 of one of the parent directories  (we can not lock the dentries
 108                 above us to prevent this, but retrying should be harmless) */
 109                 kfree(full_path);
 110                 goto cifs_bp_rename_retry;
 111         }
 112         /* DIR_SEP already set for byte  0 / vs \ but not for
 113            subsequent slashes in prepath which currently must
 114            be entered the right way - not sure if there is an alternative
 115            since the '\' is a valid posix character so we can not switch
 116            those safely to '/' if any are found in the middle of the prepath */
 117         /* BB test paths to Windows with '/' in the midst of prepath */
 118
 119         if (dfsplen) {
 120                 strncpy(full_path, cifs_sb->tcon->treeName, dfsplen);
 121                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
 122                         int i;
 123                         for (i = 0; i < dfsplen; i++) {
 124                                 if (full_path[i] == '\\')
 125                                         full_path[i] = '/';
 126                         }
 127                 }
 128         }
 129         strncpy(full_path + dfsplen, CIFS_SB(direntry->d_sb)->prepath, pplen);
 130         return full_path;
 131 }
 132
 133 struct cifsFileInfo *
 134 cifs_new_fileinfo(struct inode *newinode, __u16 fileHandle,
 135                   struct file *file, struct vfsmount *mnt, unsigned int oflags)
 136 {
 137         int oplock = 0;
 138         struct cifsFileInfo *pCifsFile;
 139         struct cifsInodeInfo *pCifsInode;
 140         struct cifs_sb_info *cifs_sb = CIFS_SB(mnt->mnt_sb);
 141
 142         pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
 143         if (pCifsFile == NULL)
 144                 return pCifsFile;
 145
 146         if (oplockEnabled)
 147                 oplock = REQ_OPLOCK;
 148
 149         pCifsFile->netfid = fileHandle;
 150         pCifsFile->pid = current->tgid;
 151         pCifsFile->pInode = igrab(newinode);
 152         pCifsFile->mnt = mnt;
 153         pCifsFile->pfile = file;
 154         pCifsFile->invalidHandle = false;
 155         pCifsFile->closePend = false;
 156         mutex_init(&pCifsFile->fh_mutex);
 157         mutex_init(&pCifsFile->lock_mutex);
 158         INIT_LIST_HEAD(&pCifsFile->llist);
 159         atomic_set(&pCifsFile->count, 1);
 160         slow_work_init(&pCifsFile->oplock_break, &cifs_oplock_break_ops);
 161
 162         write_lock(&GlobalSMBSeslock);
 163         list_add(&pCifsFile->tlist, &cifs_sb->tcon->openFileList);
 164         pCifsInode = CIFS_I(newinode);
 165         if (pCifsInode) {
 166                 /* if readable file instance put first in list*/
 167                 if (oflags & FMODE_READ)
 168                         list_add(&pCifsFile->flist, &pCifsInode->openFileList);
 169                 else
 170                         list_add_tail(&pCifsFile->flist,
 171                                       &pCifsInode->openFileList);
 172
 173                 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
 174                         pCifsInode->clientCanCacheAll = true;
 175                         pCifsInode->clientCanCacheRead = true;
 176                         cFYI(1, ("Exclusive Oplock inode %p", newinode));
 177                 } else if ((oplock & 0xF) == OPLOCK_READ)
 178                                 pCifsInode->clientCanCacheRead = true;
 179         }
 180         write_unlock(&GlobalSMBSeslock);
 181
 182         return pCifsFile;
 183 }
 184
 185 int cifs_posix_open(char *full_path, struct inode **pinode,
 186                         struct vfsmount *mnt, struct super_block *sb,
 187                         int mode, int oflags,
 188                         __u32 *poplock, __u16 *pnetfid, int xid)
 189 {
 190         int rc;
 191         FILE_UNIX_BASIC_INFO *presp_data;
 192         __u32 posix_flags = 0;
 193         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 194         struct cifs_fattr fattr;
 195
 196         cFYI(1, ("posix open %s", full_path));
 197
 198         presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
 199         if (presp_data == NULL)
 200                 return -ENOMEM;
 201
 202 /* So far cifs posix extensions can only map the following flags.
 203    There are other valid fmode oflags such as FMODE_LSEEK, FMODE_PREAD, but
 204    so far we do not seem to need them, and we can treat them as local only */
 205         if ((oflags & (FMODE_READ | FMODE_WRITE)) ==
 206                 (FMODE_READ | FMODE_WRITE))
 207                 posix_flags = SMB_O_RDWR;
 208         else if (oflags & FMODE_READ)
 209                 posix_flags = SMB_O_RDONLY;
 210         else if (oflags & FMODE_WRITE)
 211                 posix_flags = SMB_O_WRONLY;
 212         if (oflags & O_CREAT)
 213                 posix_flags |= SMB_O_CREAT;
 214         if (oflags & O_EXCL)
 215                 posix_flags |= SMB_O_EXCL;
 216         if (oflags & O_TRUNC)
 217                 posix_flags |= SMB_O_TRUNC;
 218         /* be safe and imply O_SYNC for O_DSYNC */
 219         if (oflags & O_DSYNC)
 220                 posix_flags |= SMB_O_SYNC;
 221         if (oflags & O_DIRECTORY)
 222                 posix_flags |= SMB_O_DIRECTORY;
 223         if (oflags & O_NOFOLLOW)
 224                 posix_flags |= SMB_O_NOFOLLOW;
 225         if (oflags & O_DIRECT)
 226                 posix_flags |= SMB_O_DIRECT;
 227
 228         mode &= ~current_umask();
 229         rc = CIFSPOSIXCreate(xid, cifs_sb->tcon, posix_flags, mode,
 230                         pnetfid, presp_data, poplock, full_path,
 231                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 232                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 233         if (rc)
 234                 goto posix_open_ret;
 235
 236         if (presp_data->Type == cpu_to_le32(-1))
 237                 goto posix_open_ret; /* open ok, caller does qpathinfo */
 238
 239         if (!pinode)
 240                 goto posix_open_ret; /* caller does not need info */
 241
 242         cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
 243
 244         /* get new inode and set it up */
 245         if (*pinode == NULL) {
 246                 *pinode = cifs_iget(sb, &fattr);
 247                 if (!*pinode) {
 248                         rc = -ENOMEM;
 249                         goto posix_open_ret;
 250                 }
 251         } else {
 252                 cifs_fattr_to_inode(*pinode, &fattr);
 253         }
 254
 255         if (mnt)
 256                 cifs_new_fileinfo(*pinode, *pnetfid, NULL, mnt, oflags);
 257
 258 posix_open_ret:
 259         kfree(presp_data);
 260         return rc;
 261 }
 262
 263 static void setup_cifs_dentry(struct cifsTconInfo *tcon,
 264                               struct dentry *direntry,
 265                               struct inode *newinode)
 266 {
 267         if (tcon->nocase)
 268                 direntry->d_op = &cifs_ci_dentry_ops;
 269         else
 270                 direntry->d_op = &cifs_dentry_ops;
 271         d_instantiate(direntry, newinode);
 272 }
 273
 274 /* Inode operations in similar order to how they appear in Linux file fs.h */
 275
 276 int
 277 cifs_create(struct inode *inode, struct dentry *direntry, int mode,
 278                 struct nameidata *nd)
 279 {
 280         int rc = -ENOENT;
 281         int xid;
 282         int create_options = CREATE_NOT_DIR;
 283         __u32 oplock = 0;
 284         int oflags;
 285         bool posix_create = false;
 286         /*
 287          * BB below access is probably too much for mknod to request
 288          *    but we have to do query and setpathinfo so requesting
 289          *    less could fail (unless we want to request getatr and setatr
 290          *    permissions (only).  At least for POSIX we do not have to
 291          *    request so much.
 292          */
 293         int desiredAccess = GENERIC_READ | GENERIC_WRITE;
 294         __u16 fileHandle;
 295         struct cifs_sb_info *cifs_sb;
 296         struct cifsTconInfo *tcon;
 297         char *full_path = NULL;
 298         FILE_ALL_INFO *buf = NULL;
 299         struct inode *newinode = NULL;
 300         int disposition = FILE_OVERWRITE_IF;
 301
 302         xid = GetXid();
 303
 304         cifs_sb = CIFS_SB(inode->i_sb);
 305         tcon = cifs_sb->tcon;
 306
 307         full_path = build_path_from_dentry(direntry);
 308         if (full_path == NULL) {
 309                 rc = -ENOMEM;
 310                 FreeXid(xid);
 311                 return rc;
 312         }
 313
 314         if (oplockEnabled)
 315                 oplock = REQ_OPLOCK;
 316
 317         if (nd && (nd->flags & LOOKUP_OPEN))
 318                 oflags = nd->intent.open.flags;
 319         else
 320                 oflags = FMODE_READ | SMB_O_CREAT;
 321
 322         if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
 323             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 324                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 325                 rc = cifs_posix_open(full_path, &newinode,
 326                         nd ? nd->path.mnt : NULL,
 327                         inode->i_sb, mode, oflags, &oplock, &fileHandle, xid);
 328                 /* EIO could indicate that (posix open) operation is not
 329                    supported, despite what server claimed in capability
 330                    negotation.  EREMOTE indicates DFS junction, which is not
 331                    handled in posix open */
 332
 333                 if (rc == 0) {
 334                         posix_create = true;
 335                         if (newinode == NULL) /* query inode info */
 336                                 goto cifs_create_get_file_info;
 337                         else /* success, no need to query */
 338                                 goto cifs_create_set_dentry;
 339                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
 340                          (rc != -EOPNOTSUPP) && (rc != -EINVAL))
 341                         goto cifs_create_out;
 342                 /* else fallthrough to retry, using older open call, this is
 343                    case where server does not support this SMB level, and
 344                    falsely claims capability (also get here for DFS case
 345                    which should be rare for path not covered on files) */
 346         }
 347
 348         if (nd && (nd->flags & LOOKUP_OPEN)) {
 349                 /* if the file is going to stay open, then we
 350                    need to set the desired access properly */
 351                 desiredAccess = 0;
 352                 if (oflags & FMODE_READ)
 353                         desiredAccess |= GENERIC_READ; /* is this too little? */
 354                 if (oflags & FMODE_WRITE)
 355                         desiredAccess |= GENERIC_WRITE;
 356
 357                 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 358                         disposition = FILE_CREATE;
 359                 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
 360                         disposition = FILE_OVERWRITE_IF;
 361                 else if ((oflags & O_CREAT) == O_CREAT)
 362                         disposition = FILE_OPEN_IF;
 363                 else
 364                         cFYI(1, ("Create flag not set in create function"));
 365         }
 366
 367         /* BB add processing to set equivalent of mode - e.g. via CreateX with
 368            ACLs */
 369
 370         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 371         if (buf == NULL) {
 372                 kfree(full_path);
 373                 FreeXid(xid);
 374                 return -ENOMEM;
 375         }
 376
 377         /*
 378          * if we're not using unix extensions, see if we need to set
 379          * ATTR_READONLY on the create call
 380          */
 381         if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
 382                 create_options |= CREATE_OPTION_READONLY;
 383
 384         if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
 385                 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
 386                          desiredAccess, create_options,
 387                          &fileHandle, &oplock, buf, cifs_sb->local_nls,
 388                          cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 389         else
 390                 rc = -EIO; /* no NT SMB support fall into legacy open below */
 391
 392         if (rc == -EIO) {
 393                 /* old server, retry the open legacy style */
 394                 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
 395                         desiredAccess, create_options,
 396                         &fileHandle, &oplock, buf, cifs_sb->local_nls,
 397                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 398         }
 399         if (rc) {
 400                 cFYI(1, ("cifs_create returned 0x%x", rc));
 401                 goto cifs_create_out;
 402         }
 403
 404         /* If Open reported that we actually created a file
 405            then we now have to set the mode if possible */
 406         if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
 407                 struct cifs_unix_set_info_args args = {
 408                                 .mode   = mode,
 409                                 .ctime  = NO_CHANGE_64,
 410                                 .atime  = NO_CHANGE_64,
 411                                 .mtime  = NO_CHANGE_64,
 412                                 .device = 0,
 413                 };
 414
 415                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
 416                         args.uid = (__u64) current_fsuid();
 417                         if (inode->i_mode & S_ISGID)
 418                                 args.gid = (__u64) inode->i_gid;
 419                         else
 420                                 args.gid = (__u64) current_fsgid();
 421                 } else {
 422                         args.uid = NO_CHANGE_64;
 423                         args.gid = NO_CHANGE_64;
 424                 }
 425                 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
 426                                         cifs_sb->local_nls,
 427                                         cifs_sb->mnt_cifs_flags &
 428                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 429         } else {
 430                 /* BB implement mode setting via Windows security
 431                    descriptors e.g. */
 432                 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
 433
 434                 /* Could set r/o dos attribute if mode & 0222 == 0 */
 435         }
 436
 437 cifs_create_get_file_info:
 438         /* server might mask mode so we have to query for it */
 439         if (tcon->unix_ext)
 440                 rc = cifs_get_inode_info_unix(&newinode, full_path,
 441                                               inode->i_sb, xid);
 442         else {
 443                 rc = cifs_get_inode_info(&newinode, full_path, buf,
 444                                          inode->i_sb, xid, &fileHandle);
 445                 if (newinode) {
 446                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 447                                 newinode->i_mode = mode;
 448                         if ((oplock & CIFS_CREATE_ACTION) &&
 449                             (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
 450                                 newinode->i_uid = current_fsuid();
 451                                 if (inode->i_mode & S_ISGID)
 452                                         newinode->i_gid = inode->i_gid;
 453                                 else
 454                                         newinode->i_gid = current_fsgid();
 455                         }
 456                 }
 457         }
 458
 459 cifs_create_set_dentry:
 460         if (rc == 0)
 461                 setup_cifs_dentry(tcon, direntry, newinode);
 462         else
 463                 cFYI(1, ("Create worked, get_inode_info failed rc = %d", rc));
 464
 465         /* nfsd case - nfs srv does not set nd */
 466         if ((nd == NULL) || (!(nd->flags & LOOKUP_OPEN))) {
 467                 /* mknod case - do not leave file open */
 468                 CIFSSMBClose(xid, tcon, fileHandle);
 469         } else if (!(posix_create) && (newinode)) {
 470                         cifs_new_fileinfo(newinode, fileHandle, NULL,
 471                                                 nd->path.mnt, oflags);
 472         }
 473 cifs_create_out:
 474         kfree(buf);
 475         kfree(full_path);
 476         FreeXid(xid);
 477         return rc;
 478 }
 479
 480 int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
 481                 dev_t device_number)
 482 {
 483         int rc = -EPERM;
 484         int xid;
 485         struct cifs_sb_info *cifs_sb;
 486         struct cifsTconInfo *pTcon;
 487         char *full_path = NULL;
 488         struct inode *newinode = NULL;
 489
 490         if (!old_valid_dev(device_number))
 491                 return -EINVAL;
 492
 493         xid = GetXid();
 494
 495         cifs_sb = CIFS_SB(inode->i_sb);
 496         pTcon = cifs_sb->tcon;
 497
 498         full_path = build_path_from_dentry(direntry);
 499         if (full_path == NULL)
 500                 rc = -ENOMEM;
 501         else if (pTcon->unix_ext) {
 502                 struct cifs_unix_set_info_args args = {
 503                         .mode   = mode & ~current_umask(),
 504                         .ctime  = NO_CHANGE_64,
 505                         .atime  = NO_CHANGE_64,
 506                         .mtime  = NO_CHANGE_64,
 507                         .device = device_number,
 508                 };
 509                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
 510                         args.uid = (__u64) current_fsuid();
 511                         args.gid = (__u64) current_fsgid();
 512                 } else {
 513                         args.uid = NO_CHANGE_64;
 514                         args.gid = NO_CHANGE_64;
 515                 }
 516                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
 517                                             cifs_sb->local_nls,
 518                                             cifs_sb->mnt_cifs_flags &
 519                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 520
 521                 if (!rc) {
 522                         rc = cifs_get_inode_info_unix(&newinode, full_path,
 523                                                 inode->i_sb, xid);
 524                         if (pTcon->nocase)
 525                                 direntry->d_op = &cifs_ci_dentry_ops;
 526                         else
 527                                 direntry->d_op = &cifs_dentry_ops;
 528                         if (rc == 0)
 529                                 d_instantiate(direntry, newinode);
 530                 }
 531         } else {
 532                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
 533                         int oplock = 0;
 534                         u16 fileHandle;
 535                         FILE_ALL_INFO *buf;
 536
 537                         cFYI(1, ("sfu compat create special file"));
 538
 539                         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 540                         if (buf == NULL) {
 541                                 kfree(full_path);
 542                                 rc = -ENOMEM;
 543                                 FreeXid(xid);
 544                                 return rc;
 545                         }
 546
 547                         rc = CIFSSMBOpen(xid, pTcon, full_path,
 548                                          FILE_CREATE, /* fail if exists */
 549                                          GENERIC_WRITE /* BB would
 550                                           WRITE_OWNER | WRITE_DAC be better? */,
 551                                          /* Create a file and set the
 552                                             file attribute to SYSTEM */
 553                                          CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,
 554                                          &fileHandle, &oplock, buf,
 555                                          cifs_sb->local_nls,
 556                                          cifs_sb->mnt_cifs_flags &
 557                                             CIFS_MOUNT_MAP_SPECIAL_CHR);
 558
 559                         /* BB FIXME - add handling for backlevel servers
 560                            which need legacy open and check for all
 561                            calls to SMBOpen for fallback to SMBLeagcyOpen */
 562                         if (!rc) {
 563                                 /* BB Do not bother to decode buf since no
 564                                    local inode yet to put timestamps in,
 565                                    but we can reuse it safely */
 566                                 unsigned int bytes_written;
 567                                 struct win_dev *pdev;
 568                                 pdev = (struct win_dev *)buf;
 569                                 if (S_ISCHR(mode)) {
 570                                         memcpy(pdev->type, "IntxCHR", 8);
 571                                         pdev->major =
 572                                               cpu_to_le64(MAJOR(device_number));
 573                                         pdev->minor =
 574                                               cpu_to_le64(MINOR(device_number));
 575                                         rc = CIFSSMBWrite(xid, pTcon,
 576                                                 fileHandle,
 577                                                 sizeof(struct win_dev),
 578                                                 0, &bytes_written, (char *)pdev,
 579                                                 NULL, 0);
 580                                 } else if (S_ISBLK(mode)) {
 581                                         memcpy(pdev->type, "IntxBLK", 8);
 582                                         pdev->major =
 583                                               cpu_to_le64(MAJOR(device_number));
 584                                         pdev->minor =
 585                                               cpu_to_le64(MINOR(device_number));
 586                                         rc = CIFSSMBWrite(xid, pTcon,
 587                                                 fileHandle,
 588                                                 sizeof(struct win_dev),
 589                                                 0, &bytes_written, (char *)pdev,
 590                                                 NULL, 0);
 591                                 } /* else if(S_ISFIFO */
 592                                 CIFSSMBClose(xid, pTcon, fileHandle);
 593                                 d_drop(direntry);
 594                         }
 595                         kfree(buf);
 596                         /* add code here to set EAs */
 597                 }
 598         }
 599
 600         kfree(full_path);
 601         FreeXid(xid);
 602         return rc;
 603 }
 604
 605 struct dentry *
 606 cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
 607             struct nameidata *nd)
 608 {
 609         int xid;
 610         int rc = 0; /* to get around spurious gcc warning, set to zero here */
 611         __u32 oplock = 0;
 612         __u16 fileHandle = 0;
 613         bool posix_open = false;
 614         struct cifs_sb_info *cifs_sb;
 615         struct cifsTconInfo *pTcon;
 616         struct inode *newInode = NULL;
 617         char *full_path = NULL;
 618         struct file *filp;
 619
 620         xid = GetXid();
 621
 622         cFYI(1, ("parent inode = 0x%p name is: %s and dentry = 0x%p",
 623               parent_dir_inode, direntry->d_name.name, direntry));
 624
 625         /* check whether path exists */
 626
 627         cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
 628         pTcon = cifs_sb->tcon;
 629
 630         /*
 631          * Don't allow the separator character in a path component.
 632          * The VFS will not allow "/", but "\" is allowed by posix.
 633          */
 634         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
 635                 int i;
 636                 for (i = 0; i < direntry->d_name.len; i++)
 637                         if (direntry->d_name.name[i] == '\\') {
 638                                 cFYI(1, ("Invalid file name"));
 639                                 FreeXid(xid);
 640                                 return ERR_PTR(-EINVAL);
 641                         }
 642         }
 643
 644         /*
 645          * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
 646          * the VFS handle the create.
 647          */
 648         if (nd && (nd->flags & LOOKUP_EXCL)) {
 649                 d_instantiate(direntry, NULL);
 650                 return NULL;
 651         }
 652
 653         /* can not grab the rename sem here since it would
 654         deadlock in the cases (beginning of sys_rename itself)
 655         in which we already have the sb rename sem */
 656         full_path = build_path_from_dentry(direntry);
 657         if (full_path == NULL) {
 658                 FreeXid(xid);
 659                 return ERR_PTR(-ENOMEM);
 660         }
 661
 662         if (direntry->d_inode != NULL) {
 663                 cFYI(1, ("non-NULL inode in lookup"));
 664         } else {
 665                 cFYI(1, ("NULL inode in lookup"));
 666         }
 667         cFYI(1, ("Full path: %s inode = 0x%p", full_path, direntry->d_inode));
 668
 669         /* Posix open is only called (at lookup time) for file create now.
 670          * For opens (rather than creates), because we do not know if it
 671          * is a file or directory yet, and current Samba no longer allows
 672          * us to do posix open on dirs, we could end up wasting an open call
 673          * on what turns out to be a dir. For file opens, we wait to call posix
 674          * open till cifs_open.  It could be added here (lookup) in the future
 675          * but the performance tradeoff of the extra network request when EISDIR
 676          * or EACCES is returned would have to be weighed against the 50%
 677          * reduction in network traffic in the other paths.
 678          */
 679         if (pTcon->unix_ext) {
 680                 if (nd && !(nd->flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY)) &&
 681                      (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
 682                      (nd->intent.open.flags & O_CREAT)) {
 683                         rc = cifs_posix_open(full_path, &newInode, nd->path.mnt,
 684                                         parent_dir_inode->i_sb,
 685                                         nd->intent.open.create_mode,
 686                                         nd->intent.open.flags, &oplock,
 687                                         &fileHandle, xid);
 688                         /*
 689                          * The check below works around a bug in POSIX
 690                          * open in samba versions 3.3.1 and earlier where
 691                          * open could incorrectly fail with invalid parameter.
 692                          * If either that or op not supported returned, follow
 693                          * the normal lookup.
 694                          */
 695                         if ((rc == 0) || (rc == -ENOENT))
 696                                 posix_open = true;
 697                         else if ((rc == -EINVAL) || (rc != -EOPNOTSUPP))
 698                                 pTcon->broken_posix_open = true;
 699                 }
 700                 if (!posix_open)
 701                         rc = cifs_get_inode_info_unix(&newInode, full_path,
 702                                                 parent_dir_inode->i_sb, xid);
 703         } else
 704                 rc = cifs_get_inode_info(&newInode, full_path, NULL,
 705                                 parent_dir_inode->i_sb, xid, NULL);
 706
 707         if ((rc == 0) && (newInode != NULL)) {
 708                 if (pTcon->nocase)
 709                         direntry->d_op = &cifs_ci_dentry_ops;
 710                 else
 711                         direntry->d_op = &cifs_dentry_ops;
 712                 d_add(direntry, newInode);
 713                 if (posix_open)
 714                         filp = lookup_instantiate_filp(nd, direntry, NULL);
 715                 /* since paths are not looked up by component - the parent
 716                    directories are presumed to be good here */
 717                 renew_parental_timestamps(direntry);
 718
 719         } else if (rc == -ENOENT) {
 720                 rc = 0;
 721                 direntry->d_time = jiffies;
 722                 if (pTcon->nocase)
 723                         direntry->d_op = &cifs_ci_dentry_ops;
 724                 else
 725                         direntry->d_op = &cifs_dentry_ops;
 726                 d_add(direntry, NULL);
 727         /*      if it was once a directory (but how can we tell?) we could do
 728                 shrink_dcache_parent(direntry); */
 729         } else if (rc != -EACCES) {
 730                 cERROR(1, ("Unexpected lookup error %d", rc));
 731                 /* We special case check for Access Denied - since that
 732                 is a common return code */
 733         }
 734
 735         kfree(full_path);
 736         FreeXid(xid);
 737         return ERR_PTR(rc);
 738 }
 739
 740 static int
 741 cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
 742 {
 743         int isValid = 1;
 744
 745         if (direntry->d_inode) {
 746                 if (cifs_revalidate(direntry))
 747                         return 0;
 748         } else {
 749                 cFYI(1, ("neg dentry 0x%p name = %s",
 750                          direntry, direntry->d_name.name));
 751                 if (time_after(jiffies, direntry->d_time + HZ) ||
 752                         !lookupCacheEnabled) {
 753                         d_drop(direntry);
 754                         isValid = 0;
 755                 }
 756         }
 757
 758         return isValid;
 759 }
 760
 761 /* static int cifs_d_delete(struct dentry *direntry)
 762 {
 763         int rc = 0;
 764
 765         cFYI(1, ("In cifs d_delete, name = %s", direntry->d_name.name));
 766
 767         return rc;
 768 }     */
 769
 770 const struct dentry_operations cifs_dentry_ops = {
 771         .d_revalidate = cifs_d_revalidate,
 772 /* d_delete:       cifs_d_delete,      */ /* not needed except for debugging */
 773 };
 774
 775 static int cifs_ci_hash(struct dentry *dentry, struct qstr *q)
 776 {
 777         struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
 778         unsigned long hash;
 779         int i;
 780
 781         hash = init_name_hash();
 782         for (i = 0; i < q->len; i++)
 783                 hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
 784                                          hash);
 785         q->hash = end_name_hash(hash);
 786
 787         return 0;
 788 }
 789
 790 static int cifs_ci_compare(struct dentry *dentry, struct qstr *a,
 791                            struct qstr *b)
 792 {
 793         struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
 794
 795         if ((a->len == b->len) &&
 796             (nls_strnicmp(codepage, a->name, b->name, a->len) == 0)) {
 797                 /*
 798                  * To preserve case, don't let an existing negative dentry's
 799                  * case take precedence.  If a is not a negative dentry, this
 800                  * should have no side effects
 801                  */
 802                 memcpy((void *)a->name, b->name, a->len);
 803                 return 0;
 804         }
 805         return 1;
 806 }
 807
 808 const struct dentry_operations cifs_ci_dentry_ops = {
 809         .d_revalidate = cifs_d_revalidate,
 810         .d_hash = cifs_ci_hash,
 811         .d_compare = cifs_ci_compare,
 812 };