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 #include "cifs_unicode.h"
  36
  37 static void
  38 renew_parental_timestamps(struct dentry *direntry)
  39 {
  40         /* BB check if there is a way to get the kernel to do this or if we
  41            really need this */
  42         do {
  43                 cifs_set_time(direntry, jiffies);
  44                 direntry = direntry->d_parent;
  45         } while (!IS_ROOT(direntry));
  46 }
  47
  48 char *
  49 cifs_build_path_to_root(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
  50                         struct cifs_tcon *tcon)
  51 {
  52         int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
  53         int dfsplen;
  54         char *full_path = NULL;
  55
  56         /* if no prefix path, simply set path to the root of share to "" */
  57         if (pplen == 0) {
  58                 full_path = kzalloc(1, GFP_KERNEL);
  59                 return full_path;
  60         }
  61
  62         if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
  63                 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
  64         else
  65                 dfsplen = 0;
  66
  67         full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
  68         if (full_path == NULL)
  69                 return full_path;
  70
  71         if (dfsplen)
  72                 strncpy(full_path, tcon->treeName, dfsplen);
  73         full_path[dfsplen] = CIFS_DIR_SEP(cifs_sb);
  74         strncpy(full_path + dfsplen + 1, vol->prepath, pplen);
  75         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
  76         full_path[dfsplen + pplen] = 0; /* add trailing null */
  77         return full_path;
  78 }
  79
  80 /* Note: caller must free return buffer */
  81 char *
  82 build_path_from_dentry(struct dentry *direntry)
  83 {
  84         struct dentry *temp;
  85         int namelen;
  86         int dfsplen;
  87         int pplen = 0;
  88         char *full_path;
  89         char dirsep;
  90         struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
  91         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
  92         unsigned seq;
  93
  94         dirsep = CIFS_DIR_SEP(cifs_sb);
  95         if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
  96                 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
  97         else
  98                 dfsplen = 0;
  99
 100         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
 101                 pplen = cifs_sb->prepath ? strlen(cifs_sb->prepath) + 1 : 0;
 102
 103 cifs_bp_rename_retry:
 104         namelen = dfsplen + pplen;
 105         seq = read_seqbegin(&rename_lock);
 106         rcu_read_lock();
 107         for (temp = direntry; !IS_ROOT(temp);) {
 108                 namelen += (1 + temp->d_name.len);
 109                 temp = temp->d_parent;
 110                 if (temp == NULL) {
 111                         cifs_dbg(VFS, "corrupt dentry\n");
 112                         rcu_read_unlock();
 113                         return NULL;
 114                 }
 115         }
 116         rcu_read_unlock();
 117
 118         full_path = kmalloc(namelen+1, GFP_KERNEL);
 119         if (full_path == NULL)
 120                 return full_path;
 121         full_path[namelen] = 0; /* trailing null */
 122         rcu_read_lock();
 123         for (temp = direntry; !IS_ROOT(temp);) {
 124                 spin_lock(&temp->d_lock);
 125                 namelen -= 1 + temp->d_name.len;
 126                 if (namelen < 0) {
 127                         spin_unlock(&temp->d_lock);
 128                         break;
 129                 } else {
 130                         full_path[namelen] = dirsep;
 131                         strncpy(full_path + namelen + 1, temp->d_name.name,
 132                                 temp->d_name.len);
 133                         cifs_dbg(FYI, "name: %s\n", full_path + namelen);
 134                 }
 135                 spin_unlock(&temp->d_lock);
 136                 temp = temp->d_parent;
 137                 if (temp == NULL) {
 138                         cifs_dbg(VFS, "corrupt dentry\n");
 139                         rcu_read_unlock();
 140                         kfree(full_path);
 141                         return NULL;
 142                 }
 143         }
 144         rcu_read_unlock();
 145         if (namelen != dfsplen + pplen || read_seqretry(&rename_lock, seq)) {
 146                 cifs_dbg(FYI, "did not end path lookup where expected. namelen=%ddfsplen=%d\n",
 147                          namelen, dfsplen);
 148                 /* presumably this is only possible if racing with a rename
 149                 of one of the parent directories  (we can not lock the dentries
 150                 above us to prevent this, but retrying should be harmless) */
 151                 kfree(full_path);
 152                 goto cifs_bp_rename_retry;
 153         }
 154         /* DIR_SEP already set for byte  0 / vs \ but not for
 155            subsequent slashes in prepath which currently must
 156            be entered the right way - not sure if there is an alternative
 157            since the '\' is a valid posix character so we can not switch
 158            those safely to '/' if any are found in the middle of the prepath */
 159         /* BB test paths to Windows with '/' in the midst of prepath */
 160
 161         if (pplen) {
 162                 int i;
 163
 164                 cifs_dbg(FYI, "using cifs_sb prepath <%s>\n", cifs_sb->prepath);
 165                 memcpy(full_path+dfsplen+1, cifs_sb->prepath, pplen-1);
 166                 full_path[dfsplen] = '\\';
 167                 for (i = 0; i < pplen-1; i++)
 168                         if (full_path[dfsplen+1+i] == '/')
 169                                 full_path[dfsplen+1+i] = CIFS_DIR_SEP(cifs_sb);
 170         }
 171
 172         if (dfsplen) {
 173                 strncpy(full_path, tcon->treeName, dfsplen);
 174                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
 175                         int i;
 176                         for (i = 0; i < dfsplen; i++) {
 177                                 if (full_path[i] == '\\')
 178                                         full_path[i] = '/';
 179                         }
 180                 }
 181         }
 182         return full_path;
 183 }
 184
 185 /*
 186  * Don't allow the separator character in a path component.
 187  * The VFS will not allow "/", but "\" is allowed by posix.
 188  */
 189 static int
 190 check_name(struct dentry *direntry)
 191 {
 192         struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
 193         int i;
 194
 195         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
 196                 for (i = 0; i < direntry->d_name.len; i++) {
 197                         if (direntry->d_name.name[i] == '\\') {
 198                                 cifs_dbg(FYI, "Invalid file name\n");
 199                                 return -EINVAL;
 200                         }
 201                 }
 202         }
 203         return 0;
 204 }
 205
 206
 207 /* Inode operations in similar order to how they appear in Linux file fs.h */
 208
 209 static int
 210 cifs_do_create(struct inode *inode, struct dentry *direntry, unsigned int xid,
 211                struct tcon_link *tlink, unsigned oflags, umode_t mode,
 212                __u32 *oplock, struct cifs_fid *fid)
 213 {
 214         int rc = -ENOENT;
 215         int create_options = CREATE_NOT_DIR;
 216         int desired_access;
 217         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 218         struct cifs_tcon *tcon = tlink_tcon(tlink);
 219         char *full_path = NULL;
 220         FILE_ALL_INFO *buf = NULL;
 221         struct inode *newinode = NULL;
 222         int disposition;
 223         struct TCP_Server_Info *server = tcon->ses->server;
 224         struct cifs_open_parms oparms;
 225
 226         *oplock = 0;
 227         if (tcon->ses->server->oplocks)
 228                 *oplock = REQ_OPLOCK;
 229
 230         full_path = build_path_from_dentry(direntry);
 231         if (full_path == NULL) {
 232                 rc = -ENOMEM;
 233                 goto out;
 234         }
 235
 236         if (tcon->unix_ext && cap_unix(tcon->ses) && !tcon->broken_posix_open &&
 237             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 238                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 239                 rc = cifs_posix_open(full_path, &newinode, inode->i_sb, mode,
 240                                      oflags, oplock, &fid->netfid, xid);
 241                 switch (rc) {
 242                 case 0:
 243                         if (newinode == NULL) {
 244                                 /* query inode info */
 245                                 goto cifs_create_get_file_info;
 246                         }
 247
 248                         if (S_ISDIR(newinode->i_mode)) {
 249                                 CIFSSMBClose(xid, tcon, fid->netfid);
 250                                 iput(newinode);
 251                                 rc = -EISDIR;
 252                                 goto out;
 253                         }
 254
 255                         if (!S_ISREG(newinode->i_mode)) {
 256                                 /*
 257                                  * The server may allow us to open things like
 258                                  * FIFOs, but the client isn't set up to deal
 259                                  * with that. If it's not a regular file, just
 260                                  * close it and proceed as if it were a normal
 261                                  * lookup.
 262                                  */
 263                                 CIFSSMBClose(xid, tcon, fid->netfid);
 264                                 goto cifs_create_get_file_info;
 265                         }
 266                         /* success, no need to query */
 267                         goto cifs_create_set_dentry;
 268
 269                 case -ENOENT:
 270                         goto cifs_create_get_file_info;
 271
 272                 case -EIO:
 273                 case -EINVAL:
 274                         /*
 275                          * EIO could indicate that (posix open) operation is not
 276                          * supported, despite what server claimed in capability
 277                          * negotiation.
 278                          *
 279                          * POSIX open in samba versions 3.3.1 and earlier could
 280                          * incorrectly fail with invalid parameter.
 281                          */
 282                         tcon->broken_posix_open = true;
 283                         break;
 284
 285                 case -EREMOTE:
 286                 case -EOPNOTSUPP:
 287                         /*
 288                          * EREMOTE indicates DFS junction, which is not handled
 289                          * in posix open.  If either that or op not supported
 290                          * returned, follow the normal lookup.
 291                          */
 292                         break;
 293
 294                 default:
 295                         goto out;
 296                 }
 297                 /*
 298                  * fallthrough to retry, using older open call, this is case
 299                  * where server does not support this SMB level, and falsely
 300                  * claims capability (also get here for DFS case which should be
 301                  * rare for path not covered on files)
 302                  */
 303         }
 304
 305         desired_access = 0;
 306         if (OPEN_FMODE(oflags) & FMODE_READ)
 307                 desired_access |= GENERIC_READ; /* is this too little? */
 308         if (OPEN_FMODE(oflags) & FMODE_WRITE)
 309                 desired_access |= GENERIC_WRITE;
 310
 311         disposition = FILE_OVERWRITE_IF;
 312         if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 313                 disposition = FILE_CREATE;
 314         else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
 315                 disposition = FILE_OVERWRITE_IF;
 316         else if ((oflags & O_CREAT) == O_CREAT)
 317                 disposition = FILE_OPEN_IF;
 318         else
 319                 cifs_dbg(FYI, "Create flag not set in create function\n");
 320
 321         /*
 322          * BB add processing to set equivalent of mode - e.g. via CreateX with
 323          * ACLs
 324          */
 325
 326         if (!server->ops->open) {
 327                 rc = -ENOSYS;
 328                 goto out;
 329         }
 330
 331         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 332         if (buf == NULL) {
 333                 rc = -ENOMEM;
 334                 goto out;
 335         }
 336
 337         /*
 338          * if we're not using unix extensions, see if we need to set
 339          * ATTR_READONLY on the create call
 340          */
 341         if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
 342                 create_options |= CREATE_OPTION_READONLY;
 343
 344         if (backup_cred(cifs_sb))
 345                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 346
 347         oparms.tcon = tcon;
 348         oparms.cifs_sb = cifs_sb;
 349         oparms.desired_access = desired_access;
 350         oparms.create_options = create_options;
 351         oparms.disposition = disposition;
 352         oparms.path = full_path;
 353         oparms.fid = fid;
 354         oparms.reconnect = false;
 355
 356         rc = server->ops->open(xid, &oparms, oplock, buf);
 357         if (rc) {
 358                 cifs_dbg(FYI, "cifs_create returned 0x%x\n", rc);
 359                 goto out;
 360         }
 361
 362         /*
 363          * If Open reported that we actually created a file then we now have to
 364          * set the mode if possible.
 365          */
 366         if ((tcon->unix_ext) && (*oplock & CIFS_CREATE_ACTION)) {
 367                 struct cifs_unix_set_info_args args = {
 368                                 .mode   = mode,
 369                                 .ctime  = NO_CHANGE_64,
 370                                 .atime  = NO_CHANGE_64,
 371                                 .mtime  = NO_CHANGE_64,
 372                                 .device = 0,
 373                 };
 374
 375                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
 376                         args.uid = current_fsuid();
 377                         if (inode->i_mode & S_ISGID)
 378                                 args.gid = inode->i_gid;
 379                         else
 380                                 args.gid = current_fsgid();
 381                 } else {
 382                         args.uid = INVALID_UID; /* no change */
 383                         args.gid = INVALID_GID; /* no change */
 384                 }
 385                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid->netfid,
 386                                        current->tgid);
 387         } else {
 388                 /*
 389                  * BB implement mode setting via Windows security
 390                  * descriptors e.g.
 391                  */
 392                 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
 393
 394                 /* Could set r/o dos attribute if mode & 0222 == 0 */
 395         }
 396
 397 cifs_create_get_file_info:
 398         /* server might mask mode so we have to query for it */
 399         if (tcon->unix_ext)
 400                 rc = cifs_get_inode_info_unix(&newinode, full_path, inode->i_sb,
 401                                               xid);
 402         else {
 403                 rc = cifs_get_inode_info(&newinode, full_path, buf, inode->i_sb,
 404                                          xid, fid);
 405                 if (newinode) {
 406                         if (server->ops->set_lease_key)
 407                                 server->ops->set_lease_key(newinode, fid);
 408                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 409                                 newinode->i_mode = mode;
 410                         if ((*oplock & CIFS_CREATE_ACTION) &&
 411                             (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
 412                                 newinode->i_uid = current_fsuid();
 413                                 if (inode->i_mode & S_ISGID)
 414                                         newinode->i_gid = inode->i_gid;
 415                                 else
 416                                         newinode->i_gid = current_fsgid();
 417                         }
 418                 }
 419         }
 420
 421 cifs_create_set_dentry:
 422         if (rc != 0) {
 423                 cifs_dbg(FYI, "Create worked, get_inode_info failed rc = %d\n",
 424                          rc);
 425                 goto out_err;
 426         }
 427
 428         if (S_ISDIR(newinode->i_mode)) {
 429                 rc = -EISDIR;
 430                 goto out_err;
 431         }
 432
 433         d_drop(direntry);
 434         d_add(direntry, newinode);
 435
 436 out:
 437         kfree(buf);
 438         kfree(full_path);
 439         return rc;
 440
 441 out_err:
 442         if (server->ops->close)
 443                 server->ops->close(xid, tcon, fid);
 444         if (newinode)
 445                 iput(newinode);
 446         goto out;
 447 }
 448
 449 int
 450 cifs_atomic_open(struct inode *inode, struct dentry *direntry,
 451                  struct file *file, unsigned oflags, umode_t mode,
 452                  int *opened)
 453 {
 454         int rc;
 455         unsigned int xid;
 456         struct tcon_link *tlink;
 457         struct cifs_tcon *tcon;
 458         struct TCP_Server_Info *server;
 459         struct cifs_fid fid;
 460         struct cifs_pending_open open;
 461         __u32 oplock;
 462         struct cifsFileInfo *file_info;
 463
 464         /*
 465          * Posix open is only called (at lookup time) for file create now. For
 466          * opens (rather than creates), because we do not know if it is a file
 467          * or directory yet, and current Samba no longer allows us to do posix
 468          * open on dirs, we could end up wasting an open call on what turns out
 469          * to be a dir. For file opens, we wait to call posix open till
 470          * cifs_open.  It could be added to atomic_open in the future but the
 471          * performance tradeoff of the extra network request when EISDIR or
 472          * EACCES is returned would have to be weighed against the 50% reduction
 473          * in network traffic in the other paths.
 474          */
 475         if (!(oflags & O_CREAT)) {
 476                 struct dentry *res;
 477
 478                 /*
 479                  * Check for hashed negative dentry. We have already revalidated
 480                  * the dentry and it is fine. No need to perform another lookup.
 481                  */
 482                 if (!d_in_lookup(direntry))
 483                         return -ENOENT;
 484
 485                 res = cifs_lookup(inode, direntry, 0);
 486                 if (IS_ERR(res))
 487                         return PTR_ERR(res);
 488
 489                 return finish_no_open(file, res);
 490         }
 491
 492         rc = check_name(direntry);
 493         if (rc)
 494                 return rc;
 495
 496         xid = get_xid();
 497
 498         cifs_dbg(FYI, "parent inode = 0x%p name is: %pd and dentry = 0x%p\n",
 499                  inode, direntry, direntry);
 500
 501         tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb));
 502         if (IS_ERR(tlink)) {
 503                 rc = PTR_ERR(tlink);
 504                 goto out_free_xid;
 505         }
 506
 507         tcon = tlink_tcon(tlink);
 508         server = tcon->ses->server;
 509
 510         if (server->ops->new_lease_key)
 511                 server->ops->new_lease_key(&fid);
 512
 513         cifs_add_pending_open(&fid, tlink, &open);
 514
 515         rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode,
 516                             &oplock, &fid);
 517
 518         if (rc) {
 519                 cifs_del_pending_open(&open);
 520                 goto out;
 521         }
 522
 523         if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 524                 *opened |= FILE_CREATED;
 525
 526         rc = finish_open(file, direntry, generic_file_open, opened);
 527         if (rc) {
 528                 if (server->ops->close)
 529                         server->ops->close(xid, tcon, &fid);
 530                 cifs_del_pending_open(&open);
 531                 goto out;
 532         }
 533
 534         if (file->f_flags & O_DIRECT &&
 535             CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
 536                 if (CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 537                         file->f_op = &cifs_file_direct_nobrl_ops;
 538                 else
 539                         file->f_op = &cifs_file_direct_ops;
 540                 }
 541
 542         file_info = cifs_new_fileinfo(&fid, file, tlink, oplock);
 543         if (file_info == NULL) {
 544                 if (server->ops->close)
 545                         server->ops->close(xid, tcon, &fid);
 546                 cifs_del_pending_open(&open);
 547                 fput(file);
 548                 rc = -ENOMEM;
 549         }
 550
 551 out:
 552         cifs_put_tlink(tlink);
 553 out_free_xid:
 554         free_xid(xid);
 555         return rc;
 556 }
 557
 558 int cifs_create(struct inode *inode, struct dentry *direntry, umode_t mode,
 559                 bool excl)
 560 {
 561         int rc;
 562         unsigned int xid = get_xid();
 563         /*
 564          * BB below access is probably too much for mknod to request
 565          *    but we have to do query and setpathinfo so requesting
 566          *    less could fail (unless we want to request getatr and setatr
 567          *    permissions (only).  At least for POSIX we do not have to
 568          *    request so much.
 569          */
 570         unsigned oflags = O_EXCL | O_CREAT | O_RDWR;
 571         struct tcon_link *tlink;
 572         struct cifs_tcon *tcon;
 573         struct TCP_Server_Info *server;
 574         struct cifs_fid fid;
 575         __u32 oplock;
 576
 577         cifs_dbg(FYI, "cifs_create parent inode = 0x%p name is: %pd and dentry = 0x%p\n",
 578                  inode, direntry, direntry);
 579
 580         tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb));
 581         rc = PTR_ERR(tlink);
 582         if (IS_ERR(tlink))
 583                 goto out_free_xid;
 584
 585         tcon = tlink_tcon(tlink);
 586         server = tcon->ses->server;
 587
 588         if (server->ops->new_lease_key)
 589                 server->ops->new_lease_key(&fid);
 590
 591         rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode,
 592                             &oplock, &fid);
 593         if (!rc && server->ops->close)
 594                 server->ops->close(xid, tcon, &fid);
 595
 596         cifs_put_tlink(tlink);
 597 out_free_xid:
 598         free_xid(xid);
 599         return rc;
 600 }
 601
 602 int cifs_mknod(struct inode *inode, struct dentry *direntry, umode_t mode,
 603                 dev_t device_number)
 604 {
 605         int rc = -EPERM;
 606         unsigned int xid;
 607         int create_options = CREATE_NOT_DIR | CREATE_OPTION_SPECIAL;
 608         struct cifs_sb_info *cifs_sb;
 609         struct tcon_link *tlink;
 610         struct cifs_tcon *tcon;
 611         struct cifs_io_parms io_parms;
 612         char *full_path = NULL;
 613         struct inode *newinode = NULL;
 614         __u32 oplock = 0;
 615         struct cifs_fid fid;
 616         struct cifs_open_parms oparms;
 617         FILE_ALL_INFO *buf = NULL;
 618         unsigned int bytes_written;
 619         struct win_dev *pdev;
 620         struct kvec iov[2];
 621
 622         if (!old_valid_dev(device_number))
 623                 return -EINVAL;
 624
 625         cifs_sb = CIFS_SB(inode->i_sb);
 626         tlink = cifs_sb_tlink(cifs_sb);
 627         if (IS_ERR(tlink))
 628                 return PTR_ERR(tlink);
 629
 630         tcon = tlink_tcon(tlink);
 631
 632         xid = get_xid();
 633
 634         full_path = build_path_from_dentry(direntry);
 635         if (full_path == NULL) {
 636                 rc = -ENOMEM;
 637                 goto mknod_out;
 638         }
 639
 640         if (tcon->unix_ext) {
 641                 struct cifs_unix_set_info_args args = {
 642                         .mode   = mode & ~current_umask(),
 643                         .ctime  = NO_CHANGE_64,
 644                         .atime  = NO_CHANGE_64,
 645                         .mtime  = NO_CHANGE_64,
 646                         .device = device_number,
 647                 };
 648                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
 649                         args.uid = current_fsuid();
 650                         args.gid = current_fsgid();
 651                 } else {
 652                         args.uid = INVALID_UID; /* no change */
 653                         args.gid = INVALID_GID; /* no change */
 654                 }
 655                 rc = CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
 656                                             cifs_sb->local_nls,
 657                                             cifs_remap(cifs_sb));
 658                 if (rc)
 659                         goto mknod_out;
 660
 661                 rc = cifs_get_inode_info_unix(&newinode, full_path,
 662                                                 inode->i_sb, xid);
 663
 664                 if (rc == 0)
 665                         d_instantiate(direntry, newinode);
 666                 goto mknod_out;
 667         }
 668
 669         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
 670                 goto mknod_out;
 671
 672
 673         cifs_dbg(FYI, "sfu compat create special file\n");
 674
 675         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 676         if (buf == NULL) {
 677                 kfree(full_path);
 678                 rc = -ENOMEM;
 679                 free_xid(xid);
 680                 return rc;
 681         }
 682
 683         if (backup_cred(cifs_sb))
 684                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 685
 686         oparms.tcon = tcon;
 687         oparms.cifs_sb = cifs_sb;
 688         oparms.desired_access = GENERIC_WRITE;
 689         oparms.create_options = create_options;
 690         oparms.disposition = FILE_CREATE;
 691         oparms.path = full_path;
 692         oparms.fid = &fid;
 693         oparms.reconnect = false;
 694
 695         if (tcon->ses->server->oplocks)
 696                 oplock = REQ_OPLOCK;
 697         else
 698                 oplock = 0;
 699         rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, buf);
 700         if (rc)
 701                 goto mknod_out;
 702
 703         /*
 704          * BB Do not bother to decode buf since no local inode yet to put
 705          * timestamps in, but we can reuse it safely.
 706          */
 707
 708         pdev = (struct win_dev *)buf;
 709         io_parms.pid = current->tgid;
 710         io_parms.tcon = tcon;
 711         io_parms.offset = 0;
 712         io_parms.length = sizeof(struct win_dev);
 713         iov[1].iov_base = buf;
 714         iov[1].iov_len = sizeof(struct win_dev);
 715         if (S_ISCHR(mode)) {
 716                 memcpy(pdev->type, "IntxCHR", 8);
 717                 pdev->major = cpu_to_le64(MAJOR(device_number));
 718                 pdev->minor = cpu_to_le64(MINOR(device_number));
 719                 rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
 720                                                         &bytes_written, iov, 1);
 721         } else if (S_ISBLK(mode)) {
 722                 memcpy(pdev->type, "IntxBLK", 8);
 723                 pdev->major = cpu_to_le64(MAJOR(device_number));
 724                 pdev->minor = cpu_to_le64(MINOR(device_number));
 725                 rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
 726                                                         &bytes_written, iov, 1);
 727         } /* else if (S_ISFIFO) */
 728         tcon->ses->server->ops->close(xid, tcon, &fid);
 729         d_drop(direntry);
 730
 731         /* FIXME: add code here to set EAs */
 732
 733 mknod_out:
 734         kfree(full_path);
 735         kfree(buf);
 736         free_xid(xid);
 737         cifs_put_tlink(tlink);
 738         return rc;
 739 }
 740
 741 struct dentry *
 742 cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
 743             unsigned int flags)
 744 {
 745         unsigned int xid;
 746         int rc = 0; /* to get around spurious gcc warning, set to zero here */
 747         struct cifs_sb_info *cifs_sb;
 748         struct tcon_link *tlink;
 749         struct cifs_tcon *pTcon;
 750         struct inode *newInode = NULL;
 751         char *full_path = NULL;
 752
 753         xid = get_xid();
 754
 755         cifs_dbg(FYI, "parent inode = 0x%p name is: %pd and dentry = 0x%p\n",
 756                  parent_dir_inode, direntry, direntry);
 757
 758         /* check whether path exists */
 759
 760         cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
 761         tlink = cifs_sb_tlink(cifs_sb);
 762         if (IS_ERR(tlink)) {
 763                 free_xid(xid);
 764                 return (struct dentry *)tlink;
 765         }
 766         pTcon = tlink_tcon(tlink);
 767
 768         rc = check_name(direntry);
 769         if (rc)
 770                 goto lookup_out;
 771
 772         /* can not grab the rename sem here since it would
 773         deadlock in the cases (beginning of sys_rename itself)
 774         in which we already have the sb rename sem */
 775         full_path = build_path_from_dentry(direntry);
 776         if (full_path == NULL) {
 777                 rc = -ENOMEM;
 778                 goto lookup_out;
 779         }
 780
 781         if (d_really_is_positive(direntry)) {
 782                 cifs_dbg(FYI, "non-NULL inode in lookup\n");
 783         } else {
 784                 cifs_dbg(FYI, "NULL inode in lookup\n");
 785         }
 786         cifs_dbg(FYI, "Full path: %s inode = 0x%p\n",
 787                  full_path, d_inode(direntry));
 788
 789         if (pTcon->unix_ext) {
 790                 rc = cifs_get_inode_info_unix(&newInode, full_path,
 791                                               parent_dir_inode->i_sb, xid);
 792         } else {
 793                 rc = cifs_get_inode_info(&newInode, full_path, NULL,
 794                                 parent_dir_inode->i_sb, xid, NULL);
 795         }
 796
 797         if ((rc == 0) && (newInode != NULL)) {
 798                 d_add(direntry, newInode);
 799                 /* since paths are not looked up by component - the parent
 800                    directories are presumed to be good here */
 801                 renew_parental_timestamps(direntry);
 802
 803         } else if (rc == -ENOENT) {
 804                 rc = 0;
 805                 cifs_set_time(direntry, jiffies);
 806                 d_add(direntry, NULL);
 807         /*      if it was once a directory (but how can we tell?) we could do
 808                 shrink_dcache_parent(direntry); */
 809         } else if (rc != -EACCES) {
 810                 cifs_dbg(FYI, "Unexpected lookup error %d\n", rc);
 811                 /* We special case check for Access Denied - since that
 812                 is a common return code */
 813         }
 814
 815 lookup_out:
 816         kfree(full_path);
 817         cifs_put_tlink(tlink);
 818         free_xid(xid);
 819         return ERR_PTR(rc);
 820 }
 821
 822 static int
 823 cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
 824 {
 825         if (flags & LOOKUP_RCU)
 826                 return -ECHILD;
 827
 828         if (d_really_is_positive(direntry)) {
 829                 if (cifs_revalidate_dentry(direntry))
 830                         return 0;
 831                 else {
 832                         /*
 833                          * If the inode wasn't known to be a dfs entry when
 834                          * the dentry was instantiated, such as when created
 835                          * via ->readdir(), it needs to be set now since the
 836                          * attributes will have been updated by
 837                          * cifs_revalidate_dentry().
 838                          */
 839                         if (IS_AUTOMOUNT(d_inode(direntry)) &&
 840                            !(direntry->d_flags & DCACHE_NEED_AUTOMOUNT)) {
 841                                 spin_lock(&direntry->d_lock);
 842                                 direntry->d_flags |= DCACHE_NEED_AUTOMOUNT;
 843                                 spin_unlock(&direntry->d_lock);
 844                         }
 845
 846                         return 1;
 847                 }
 848         }
 849
 850         /*
 851          * This may be nfsd (or something), anyway, we can't see the
 852          * intent of this. So, since this can be for creation, drop it.
 853          */
 854         if (!flags)
 855                 return 0;
 856
 857         /*
 858          * Drop the negative dentry, in order to make sure to use the
 859          * case sensitive name which is specified by user if this is
 860          * for creation.
 861          */
 862         if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
 863                 return 0;
 864
 865         if (time_after(jiffies, cifs_get_time(direntry) + HZ) || !lookupCacheEnabled)
 866                 return 0;
 867
 868         return 1;
 869 }
 870
 871 /* static int cifs_d_delete(struct dentry *direntry)
 872 {
 873         int rc = 0;
 874
 875         cifs_dbg(FYI, "In cifs d_delete, name = %pd\n", direntry);
 876
 877         return rc;
 878 }     */
 879
 880 const struct dentry_operations cifs_dentry_ops = {
 881         .d_revalidate = cifs_d_revalidate,
 882         .d_automount = cifs_dfs_d_automount,
 883 /* d_delete:       cifs_d_delete,      */ /* not needed except for debugging */
 884 };
 885
 886 static int cifs_ci_hash(const struct dentry *dentry, struct qstr *q)
 887 {
 888         struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
 889         unsigned long hash;
 890         wchar_t c;
 891         int i, charlen;
 892
 893         hash = init_name_hash(dentry);
 894         for (i = 0; i < q->len; i += charlen) {
 895                 charlen = codepage->char2uni(&q->name[i], q->len - i, &c);
 896                 /* error out if we can't convert the character */
 897                 if (unlikely(charlen < 0))
 898                         return charlen;
 899                 hash = partial_name_hash(cifs_toupper(c), hash);
 900         }
 901         q->hash = end_name_hash(hash);
 902
 903         return 0;
 904 }
 905
 906 static int cifs_ci_compare(const struct dentry *dentry,
 907                 unsigned int len, const char *str, const struct qstr *name)
 908 {
 909         struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
 910         wchar_t c1, c2;
 911         int i, l1, l2;
 912
 913         /*
 914          * We make the assumption here that uppercase characters in the local
 915          * codepage are always the same length as their lowercase counterparts.
 916          *
 917          * If that's ever not the case, then this will fail to match it.
 918          */
 919         if (name->len != len)
 920                 return 1;
 921
 922         for (i = 0; i < len; i += l1) {
 923                 /* Convert characters in both strings to UTF-16. */
 924                 l1 = codepage->char2uni(&str[i], len - i, &c1);
 925                 l2 = codepage->char2uni(&name->name[i], name->len - i, &c2);
 926
 927                 /*
 928                  * If we can't convert either character, just declare it to
 929                  * be 1 byte long and compare the original byte.
 930                  */
 931                 if (unlikely(l1 < 0 && l2 < 0)) {
 932                         if (str[i] != name->name[i])
 933                                 return 1;
 934                         l1 = 1;
 935                         continue;
 936                 }
 937
 938                 /*
 939                  * Here, we again ass|u|me that upper/lowercase versions of
 940                  * a character are the same length in the local NLS.
 941                  */
 942                 if (l1 != l2)
 943                         return 1;
 944
 945                 /* Now compare uppercase versions of these characters */
 946                 if (cifs_toupper(c1) != cifs_toupper(c2))
 947                         return 1;
 948         }
 949
 950         return 0;
 951 }
 952
 953 const struct dentry_operations cifs_ci_dentry_ops = {
 954         .d_revalidate = cifs_d_revalidate,
 955         .d_hash = cifs_ci_hash,
 956         .d_compare = cifs_ci_compare,
 957         .d_automount = cifs_dfs_d_automount,
 958 };