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