linux/fs/cifs/inode.c
<<
>>
Prefs
   1/*
   2 *   fs/cifs/inode.c
   3 *
   4 *   Copyright (C) International Business Machines  Corp., 2002,2010
   5 *   Author(s): Steve French (sfrench@us.ibm.com)
   6 *
   7 *   This library is free software; you can redistribute it and/or modify
   8 *   it under the terms of the GNU Lesser General Public License as published
   9 *   by the Free Software Foundation; either version 2.1 of the License, or
  10 *   (at your option) any later version.
  11 *
  12 *   This library is distributed in the hope that it will be useful,
  13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15 *   the GNU Lesser General Public License for more details.
  16 *
  17 *   You should have received a copy of the GNU Lesser General Public License
  18 *   along with this library; if not, write to the Free Software
  19 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20 */
  21#include <linux/fs.h>
  22#include <linux/stat.h>
  23#include <linux/slab.h>
  24#include <linux/pagemap.h>
  25#include <asm/div64.h>
  26#include "cifsfs.h"
  27#include "cifspdu.h"
  28#include "cifsglob.h"
  29#include "cifsproto.h"
  30#include "cifs_debug.h"
  31#include "cifs_fs_sb.h"
  32#include "fscache.h"
  33
  34
  35static void cifs_set_ops(struct inode *inode)
  36{
  37        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
  38
  39        switch (inode->i_mode & S_IFMT) {
  40        case S_IFREG:
  41                inode->i_op = &cifs_file_inode_ops;
  42                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
  43                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  44                                inode->i_fop = &cifs_file_direct_nobrl_ops;
  45                        else
  46                                inode->i_fop = &cifs_file_direct_ops;
  47                } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
  48                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  49                                inode->i_fop = &cifs_file_strict_nobrl_ops;
  50                        else
  51                                inode->i_fop = &cifs_file_strict_ops;
  52                } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  53                        inode->i_fop = &cifs_file_nobrl_ops;
  54                else { /* not direct, send byte range locks */
  55                        inode->i_fop = &cifs_file_ops;
  56                }
  57
  58                /* check if server can support readpages */
  59                if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
  60                                PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
  61                        inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
  62                else
  63                        inode->i_data.a_ops = &cifs_addr_ops;
  64                break;
  65        case S_IFDIR:
  66#ifdef CONFIG_CIFS_DFS_UPCALL
  67                if (IS_AUTOMOUNT(inode)) {
  68                        inode->i_op = &cifs_dfs_referral_inode_operations;
  69                } else {
  70#else /* NO DFS support, treat as a directory */
  71                {
  72#endif
  73                        inode->i_op = &cifs_dir_inode_ops;
  74                        inode->i_fop = &cifs_dir_ops;
  75                }
  76                break;
  77        case S_IFLNK:
  78                inode->i_op = &cifs_symlink_inode_ops;
  79                break;
  80        default:
  81                init_special_inode(inode, inode->i_mode, inode->i_rdev);
  82                break;
  83        }
  84}
  85
  86/* check inode attributes against fattr. If they don't match, tag the
  87 * inode for cache invalidation
  88 */
  89static void
  90cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
  91{
  92        struct cifsInodeInfo *cifs_i = CIFS_I(inode);
  93
  94        cifs_dbg(FYI, "%s: revalidating inode %llu\n",
  95                 __func__, cifs_i->uniqueid);
  96
  97        if (inode->i_state & I_NEW) {
  98                cifs_dbg(FYI, "%s: inode %llu is new\n",
  99                         __func__, cifs_i->uniqueid);
 100                return;
 101        }
 102
 103        /* don't bother with revalidation if we have an oplock */
 104        if (cifs_i->clientCanCacheRead) {
 105                cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
 106                         __func__, cifs_i->uniqueid);
 107                return;
 108        }
 109
 110         /* revalidate if mtime or size have changed */
 111        if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
 112            cifs_i->server_eof == fattr->cf_eof) {
 113                cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
 114                         __func__, cifs_i->uniqueid);
 115                return;
 116        }
 117
 118        cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
 119                 __func__, cifs_i->uniqueid);
 120        cifs_i->invalid_mapping = true;
 121}
 122
 123/* populate an inode with info from a cifs_fattr struct */
 124void
 125cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 126{
 127        struct cifsInodeInfo *cifs_i = CIFS_I(inode);
 128        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 129
 130        cifs_revalidate_cache(inode, fattr);
 131
 132        spin_lock(&inode->i_lock);
 133        inode->i_atime = fattr->cf_atime;
 134        inode->i_mtime = fattr->cf_mtime;
 135        inode->i_ctime = fattr->cf_ctime;
 136        inode->i_rdev = fattr->cf_rdev;
 137        set_nlink(inode, fattr->cf_nlink);
 138        inode->i_uid = fattr->cf_uid;
 139        inode->i_gid = fattr->cf_gid;
 140
 141        /* if dynperm is set, don't clobber existing mode */
 142        if (inode->i_state & I_NEW ||
 143            !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
 144                inode->i_mode = fattr->cf_mode;
 145
 146        cifs_i->cifsAttrs = fattr->cf_cifsattrs;
 147
 148        if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
 149                cifs_i->time = 0;
 150        else
 151                cifs_i->time = jiffies;
 152
 153        cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
 154
 155        cifs_i->server_eof = fattr->cf_eof;
 156        /*
 157         * Can't safely change the file size here if the client is writing to
 158         * it due to potential races.
 159         */
 160        if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
 161                i_size_write(inode, fattr->cf_eof);
 162
 163                /*
 164                 * i_blocks is not related to (i_size / i_blksize),
 165                 * but instead 512 byte (2**9) size is required for
 166                 * calculating num blocks.
 167                 */
 168                inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
 169        }
 170        spin_unlock(&inode->i_lock);
 171
 172        if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
 173                inode->i_flags |= S_AUTOMOUNT;
 174        if (inode->i_state & I_NEW)
 175                cifs_set_ops(inode);
 176}
 177
 178void
 179cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
 180{
 181        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 182
 183        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 184                return;
 185
 186        fattr->cf_uniqueid = iunique(sb, ROOT_I);
 187}
 188
 189/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
 190void
 191cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
 192                         struct cifs_sb_info *cifs_sb)
 193{
 194        memset(fattr, 0, sizeof(*fattr));
 195        fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
 196        fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
 197        fattr->cf_eof = le64_to_cpu(info->EndOfFile);
 198
 199        fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
 200        fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
 201        fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
 202        fattr->cf_mode = le64_to_cpu(info->Permissions);
 203
 204        /*
 205         * Since we set the inode type below we need to mask off
 206         * to avoid strange results if bits set above.
 207         */
 208        fattr->cf_mode &= ~S_IFMT;
 209        switch (le32_to_cpu(info->Type)) {
 210        case UNIX_FILE:
 211                fattr->cf_mode |= S_IFREG;
 212                fattr->cf_dtype = DT_REG;
 213                break;
 214        case UNIX_SYMLINK:
 215                fattr->cf_mode |= S_IFLNK;
 216                fattr->cf_dtype = DT_LNK;
 217                break;
 218        case UNIX_DIR:
 219                fattr->cf_mode |= S_IFDIR;
 220                fattr->cf_dtype = DT_DIR;
 221                break;
 222        case UNIX_CHARDEV:
 223                fattr->cf_mode |= S_IFCHR;
 224                fattr->cf_dtype = DT_CHR;
 225                fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 226                                       le64_to_cpu(info->DevMinor) & MINORMASK);
 227                break;
 228        case UNIX_BLOCKDEV:
 229                fattr->cf_mode |= S_IFBLK;
 230                fattr->cf_dtype = DT_BLK;
 231                fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 232                                       le64_to_cpu(info->DevMinor) & MINORMASK);
 233                break;
 234        case UNIX_FIFO:
 235                fattr->cf_mode |= S_IFIFO;
 236                fattr->cf_dtype = DT_FIFO;
 237                break;
 238        case UNIX_SOCKET:
 239                fattr->cf_mode |= S_IFSOCK;
 240                fattr->cf_dtype = DT_SOCK;
 241                break;
 242        default:
 243                /* safest to call it a file if we do not know */
 244                fattr->cf_mode |= S_IFREG;
 245                fattr->cf_dtype = DT_REG;
 246                cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
 247                break;
 248        }
 249
 250        fattr->cf_uid = cifs_sb->mnt_uid;
 251        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
 252                u64 id = le64_to_cpu(info->Uid);
 253                if (id < ((uid_t)-1)) {
 254                        kuid_t uid = make_kuid(&init_user_ns, id);
 255                        if (uid_valid(uid))
 256                                fattr->cf_uid = uid;
 257                }
 258        }
 259        
 260        fattr->cf_gid = cifs_sb->mnt_gid;
 261        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
 262                u64 id = le64_to_cpu(info->Gid);
 263                if (id < ((gid_t)-1)) {
 264                        kgid_t gid = make_kgid(&init_user_ns, id);
 265                        if (gid_valid(gid))
 266                                fattr->cf_gid = gid;
 267                }
 268        }
 269
 270        fattr->cf_nlink = le64_to_cpu(info->Nlinks);
 271}
 272
 273/*
 274 * Fill a cifs_fattr struct with fake inode info.
 275 *
 276 * Needed to setup cifs_fattr data for the directory which is the
 277 * junction to the new submount (ie to setup the fake directory
 278 * which represents a DFS referral).
 279 */
 280static void
 281cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
 282{
 283        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 284
 285        cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
 286
 287        memset(fattr, 0, sizeof(*fattr));
 288        fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
 289        fattr->cf_uid = cifs_sb->mnt_uid;
 290        fattr->cf_gid = cifs_sb->mnt_gid;
 291        fattr->cf_atime = CURRENT_TIME;
 292        fattr->cf_ctime = CURRENT_TIME;
 293        fattr->cf_mtime = CURRENT_TIME;
 294        fattr->cf_nlink = 2;
 295        fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
 296}
 297
 298static int
 299cifs_get_file_info_unix(struct file *filp)
 300{
 301        int rc;
 302        unsigned int xid;
 303        FILE_UNIX_BASIC_INFO find_data;
 304        struct cifs_fattr fattr;
 305        struct inode *inode = file_inode(filp);
 306        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 307        struct cifsFileInfo *cfile = filp->private_data;
 308        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 309
 310        xid = get_xid();
 311        rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
 312        if (!rc) {
 313                cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
 314        } else if (rc == -EREMOTE) {
 315                cifs_create_dfs_fattr(&fattr, inode->i_sb);
 316                rc = 0;
 317        }
 318
 319        cifs_fattr_to_inode(inode, &fattr);
 320        free_xid(xid);
 321        return rc;
 322}
 323
 324int cifs_get_inode_info_unix(struct inode **pinode,
 325                             const unsigned char *full_path,
 326                             struct super_block *sb, unsigned int xid)
 327{
 328        int rc;
 329        FILE_UNIX_BASIC_INFO find_data;
 330        struct cifs_fattr fattr;
 331        struct cifs_tcon *tcon;
 332        struct tcon_link *tlink;
 333        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 334
 335        cifs_dbg(FYI, "Getting info on %s\n", full_path);
 336
 337        tlink = cifs_sb_tlink(cifs_sb);
 338        if (IS_ERR(tlink))
 339                return PTR_ERR(tlink);
 340        tcon = tlink_tcon(tlink);
 341
 342        /* could have done a find first instead but this returns more info */
 343        rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
 344                                  cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 345                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
 346        cifs_put_tlink(tlink);
 347
 348        if (!rc) {
 349                cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
 350        } else if (rc == -EREMOTE) {
 351                cifs_create_dfs_fattr(&fattr, sb);
 352                rc = 0;
 353        } else {
 354                return rc;
 355        }
 356
 357        /* check for Minshall+French symlinks */
 358        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
 359                int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
 360                if (tmprc)
 361                        cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
 362        }
 363
 364        if (*pinode == NULL) {
 365                /* get new inode */
 366                cifs_fill_uniqueid(sb, &fattr);
 367                *pinode = cifs_iget(sb, &fattr);
 368                if (!*pinode)
 369                        rc = -ENOMEM;
 370        } else {
 371                /* we already have inode, update it */
 372                cifs_fattr_to_inode(*pinode, &fattr);
 373        }
 374
 375        return rc;
 376}
 377
 378static int
 379cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
 380              struct cifs_sb_info *cifs_sb, unsigned int xid)
 381{
 382        int rc;
 383        int oplock = 0;
 384        __u16 netfid;
 385        struct tcon_link *tlink;
 386        struct cifs_tcon *tcon;
 387        struct cifs_io_parms io_parms;
 388        char buf[24];
 389        unsigned int bytes_read;
 390        char *pbuf;
 391
 392        pbuf = buf;
 393
 394        fattr->cf_mode &= ~S_IFMT;
 395
 396        if (fattr->cf_eof == 0) {
 397                fattr->cf_mode |= S_IFIFO;
 398                fattr->cf_dtype = DT_FIFO;
 399                return 0;
 400        } else if (fattr->cf_eof < 8) {
 401                fattr->cf_mode |= S_IFREG;
 402                fattr->cf_dtype = DT_REG;
 403                return -EINVAL;  /* EOPNOTSUPP? */
 404        }
 405
 406        tlink = cifs_sb_tlink(cifs_sb);
 407        if (IS_ERR(tlink))
 408                return PTR_ERR(tlink);
 409        tcon = tlink_tcon(tlink);
 410
 411        rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
 412                         CREATE_NOT_DIR, &netfid, &oplock, NULL,
 413                         cifs_sb->local_nls,
 414                         cifs_sb->mnt_cifs_flags &
 415                                CIFS_MOUNT_MAP_SPECIAL_CHR);
 416        if (rc == 0) {
 417                int buf_type = CIFS_NO_BUFFER;
 418                        /* Read header */
 419                io_parms.netfid = netfid;
 420                io_parms.pid = current->tgid;
 421                io_parms.tcon = tcon;
 422                io_parms.offset = 0;
 423                io_parms.length = 24;
 424                rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
 425                                 &buf_type);
 426                if ((rc == 0) && (bytes_read >= 8)) {
 427                        if (memcmp("IntxBLK", pbuf, 8) == 0) {
 428                                cifs_dbg(FYI, "Block device\n");
 429                                fattr->cf_mode |= S_IFBLK;
 430                                fattr->cf_dtype = DT_BLK;
 431                                if (bytes_read == 24) {
 432                                        /* we have enough to decode dev num */
 433                                        __u64 mjr; /* major */
 434                                        __u64 mnr; /* minor */
 435                                        mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
 436                                        mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
 437                                        fattr->cf_rdev = MKDEV(mjr, mnr);
 438                                }
 439                        } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
 440                                cifs_dbg(FYI, "Char device\n");
 441                                fattr->cf_mode |= S_IFCHR;
 442                                fattr->cf_dtype = DT_CHR;
 443                                if (bytes_read == 24) {
 444                                        /* we have enough to decode dev num */
 445                                        __u64 mjr; /* major */
 446                                        __u64 mnr; /* minor */
 447                                        mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
 448                                        mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
 449                                        fattr->cf_rdev = MKDEV(mjr, mnr);
 450                                }
 451                        } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
 452                                cifs_dbg(FYI, "Symlink\n");
 453                                fattr->cf_mode |= S_IFLNK;
 454                                fattr->cf_dtype = DT_LNK;
 455                        } else {
 456                                fattr->cf_mode |= S_IFREG; /* file? */
 457                                fattr->cf_dtype = DT_REG;
 458                                rc = -EOPNOTSUPP;
 459                        }
 460                } else {
 461                        fattr->cf_mode |= S_IFREG; /* then it is a file */
 462                        fattr->cf_dtype = DT_REG;
 463                        rc = -EOPNOTSUPP; /* or some unknown SFU type */
 464                }
 465                CIFSSMBClose(xid, tcon, netfid);
 466        }
 467        cifs_put_tlink(tlink);
 468        return rc;
 469}
 470
 471#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID)  /* SETFILEBITS valid bits */
 472
 473/*
 474 * Fetch mode bits as provided by SFU.
 475 *
 476 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
 477 */
 478static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
 479                         struct cifs_sb_info *cifs_sb, unsigned int xid)
 480{
 481#ifdef CONFIG_CIFS_XATTR
 482        ssize_t rc;
 483        char ea_value[4];
 484        __u32 mode;
 485        struct tcon_link *tlink;
 486        struct cifs_tcon *tcon;
 487
 488        tlink = cifs_sb_tlink(cifs_sb);
 489        if (IS_ERR(tlink))
 490                return PTR_ERR(tlink);
 491        tcon = tlink_tcon(tlink);
 492
 493        rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
 494                            ea_value, 4 /* size of buf */, cifs_sb->local_nls,
 495                            cifs_sb->mnt_cifs_flags &
 496                                CIFS_MOUNT_MAP_SPECIAL_CHR);
 497        cifs_put_tlink(tlink);
 498        if (rc < 0)
 499                return (int)rc;
 500        else if (rc > 3) {
 501                mode = le32_to_cpu(*((__le32 *)ea_value));
 502                fattr->cf_mode &= ~SFBITS_MASK;
 503                cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
 504                         mode, fattr->cf_mode);
 505                fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
 506                cifs_dbg(FYI, "special mode bits 0%o\n", mode);
 507        }
 508
 509        return 0;
 510#else
 511        return -EOPNOTSUPP;
 512#endif
 513}
 514
 515/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
 516static void
 517cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
 518                       struct cifs_sb_info *cifs_sb, bool adjust_tz)
 519{
 520        struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 521
 522        memset(fattr, 0, sizeof(*fattr));
 523        fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
 524        if (info->DeletePending)
 525                fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
 526
 527        if (info->LastAccessTime)
 528                fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
 529        else
 530                fattr->cf_atime = CURRENT_TIME;
 531
 532        fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
 533        fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
 534
 535        if (adjust_tz) {
 536                fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
 537                fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
 538        }
 539
 540        fattr->cf_eof = le64_to_cpu(info->EndOfFile);
 541        fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
 542        fattr->cf_createtime = le64_to_cpu(info->CreationTime);
 543
 544        if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
 545                fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
 546                fattr->cf_dtype = DT_DIR;
 547                /*
 548                 * Server can return wrong NumberOfLinks value for directories
 549                 * when Unix extensions are disabled - fake it.
 550                 */
 551                fattr->cf_nlink = 2;
 552        } else {
 553                fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
 554                fattr->cf_dtype = DT_REG;
 555
 556                /* clear write bits if ATTR_READONLY is set */
 557                if (fattr->cf_cifsattrs & ATTR_READONLY)
 558                        fattr->cf_mode &= ~(S_IWUGO);
 559
 560                fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
 561                if (fattr->cf_nlink < 1) {
 562                        cifs_dbg(1, "replacing bogus file nlink value %u\n",
 563                                fattr->cf_nlink);
 564                        fattr->cf_nlink = 1;
 565                }
 566        }
 567
 568        fattr->cf_uid = cifs_sb->mnt_uid;
 569        fattr->cf_gid = cifs_sb->mnt_gid;
 570}
 571
 572static int
 573cifs_get_file_info(struct file *filp)
 574{
 575        int rc;
 576        unsigned int xid;
 577        FILE_ALL_INFO find_data;
 578        struct cifs_fattr fattr;
 579        struct inode *inode = file_inode(filp);
 580        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 581        struct cifsFileInfo *cfile = filp->private_data;
 582        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 583        struct TCP_Server_Info *server = tcon->ses->server;
 584
 585        if (!server->ops->query_file_info)
 586                return -ENOSYS;
 587
 588        xid = get_xid();
 589        rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
 590        switch (rc) {
 591        case 0:
 592                cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
 593                break;
 594        case -EREMOTE:
 595                cifs_create_dfs_fattr(&fattr, inode->i_sb);
 596                rc = 0;
 597                break;
 598        case -EOPNOTSUPP:
 599        case -EINVAL:
 600                /*
 601                 * FIXME: legacy server -- fall back to path-based call?
 602                 * for now, just skip revalidating and mark inode for
 603                 * immediate reval.
 604                 */
 605                rc = 0;
 606                CIFS_I(inode)->time = 0;
 607        default:
 608                goto cgfi_exit;
 609        }
 610
 611        /*
 612         * don't bother with SFU junk here -- just mark inode as needing
 613         * revalidation.
 614         */
 615        fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
 616        fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
 617        cifs_fattr_to_inode(inode, &fattr);
 618cgfi_exit:
 619        free_xid(xid);
 620        return rc;
 621}
 622
 623int
 624cifs_get_inode_info(struct inode **inode, const char *full_path,
 625                    FILE_ALL_INFO *data, struct super_block *sb, int xid,
 626                    const __u16 *fid)
 627{
 628        bool validinum = false;
 629        __u16 srchflgs;
 630        int rc = 0, tmprc = ENOSYS;
 631        struct cifs_tcon *tcon;
 632        struct TCP_Server_Info *server;
 633        struct tcon_link *tlink;
 634        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 635        char *buf = NULL;
 636        bool adjust_tz = false;
 637        struct cifs_fattr fattr;
 638        struct cifs_search_info *srchinf = NULL;
 639
 640        tlink = cifs_sb_tlink(cifs_sb);
 641        if (IS_ERR(tlink))
 642                return PTR_ERR(tlink);
 643        tcon = tlink_tcon(tlink);
 644        server = tcon->ses->server;
 645
 646        cifs_dbg(FYI, "Getting info on %s\n", full_path);
 647
 648        if ((data == NULL) && (*inode != NULL)) {
 649                if (CIFS_I(*inode)->clientCanCacheRead) {
 650                        cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
 651                        goto cgii_exit;
 652                }
 653        }
 654
 655        /* if inode info is not passed, get it from server */
 656        if (data == NULL) {
 657                if (!server->ops->query_path_info) {
 658                        rc = -ENOSYS;
 659                        goto cgii_exit;
 660                }
 661                buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 662                if (buf == NULL) {
 663                        rc = -ENOMEM;
 664                        goto cgii_exit;
 665                }
 666                data = (FILE_ALL_INFO *)buf;
 667                rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
 668                                                  data, &adjust_tz);
 669        }
 670
 671        if (!rc) {
 672                cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *)data, cifs_sb,
 673                                       adjust_tz);
 674        } else if (rc == -EREMOTE) {
 675                cifs_create_dfs_fattr(&fattr, sb);
 676                rc = 0;
 677        } else if (rc == -EACCES && backup_cred(cifs_sb)) {
 678                        srchinf = kzalloc(sizeof(struct cifs_search_info),
 679                                                GFP_KERNEL);
 680                        if (srchinf == NULL) {
 681                                rc = -ENOMEM;
 682                                goto cgii_exit;
 683                        }
 684
 685                        srchinf->endOfSearch = false;
 686                        srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
 687
 688                        srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
 689                                        CIFS_SEARCH_CLOSE_AT_END |
 690                                        CIFS_SEARCH_BACKUP_SEARCH;
 691
 692                        rc = CIFSFindFirst(xid, tcon, full_path,
 693                                cifs_sb, NULL, srchflgs, srchinf, false);
 694                        if (!rc) {
 695                                data =
 696                                (FILE_ALL_INFO *)srchinf->srch_entries_start;
 697
 698                                cifs_dir_info_to_fattr(&fattr,
 699                                (FILE_DIRECTORY_INFO *)data, cifs_sb);
 700                                fattr.cf_uniqueid = le64_to_cpu(
 701                                ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
 702                                validinum = true;
 703
 704                                cifs_buf_release(srchinf->ntwrk_buf_start);
 705                        }
 706                        kfree(srchinf);
 707        } else
 708                goto cgii_exit;
 709
 710        /*
 711         * If an inode wasn't passed in, then get the inode number
 712         *
 713         * Is an i_ino of zero legal? Can we use that to check if the server
 714         * supports returning inode numbers?  Are there other sanity checks we
 715         * can use to ensure that the server is really filling in that field?
 716         */
 717        if (*inode == NULL) {
 718                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 719                        if (validinum == false) {
 720                                if (server->ops->get_srv_inum)
 721                                        tmprc = server->ops->get_srv_inum(xid,
 722                                                tcon, cifs_sb, full_path,
 723                                                &fattr.cf_uniqueid, data);
 724                                if (tmprc) {
 725                                        cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
 726                                                 tmprc);
 727                                        fattr.cf_uniqueid = iunique(sb, ROOT_I);
 728                                        cifs_autodisable_serverino(cifs_sb);
 729                                }
 730                        }
 731                } else
 732                        fattr.cf_uniqueid = iunique(sb, ROOT_I);
 733        } else
 734                fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
 735
 736        /* query for SFU type info if supported and needed */
 737        if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
 738            cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
 739                tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
 740                if (tmprc)
 741                        cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
 742        }
 743
 744#ifdef CONFIG_CIFS_ACL
 745        /* fill in 0777 bits from ACL */
 746        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
 747                rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
 748                if (rc) {
 749                        cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
 750                                 __func__, rc);
 751                        goto cgii_exit;
 752                }
 753        }
 754#endif /* CONFIG_CIFS_ACL */
 755
 756        /* fill in remaining high mode bits e.g. SUID, VTX */
 757        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
 758                cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
 759
 760        /* check for Minshall+French symlinks */
 761        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
 762                tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
 763                if (tmprc)
 764                        cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
 765        }
 766
 767        if (!*inode) {
 768                *inode = cifs_iget(sb, &fattr);
 769                if (!*inode)
 770                        rc = -ENOMEM;
 771        } else {
 772                cifs_fattr_to_inode(*inode, &fattr);
 773        }
 774
 775cgii_exit:
 776        kfree(buf);
 777        cifs_put_tlink(tlink);
 778        return rc;
 779}
 780
 781static const struct inode_operations cifs_ipc_inode_ops = {
 782        .lookup = cifs_lookup,
 783};
 784
 785static int
 786cifs_find_inode(struct inode *inode, void *opaque)
 787{
 788        struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
 789
 790        /* don't match inode with different uniqueid */
 791        if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
 792                return 0;
 793
 794        /* use createtime like an i_generation field */
 795        if (CIFS_I(inode)->createtime != fattr->cf_createtime)
 796                return 0;
 797
 798        /* don't match inode of different type */
 799        if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
 800                return 0;
 801
 802        /* if it's not a directory or has no dentries, then flag it */
 803        if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
 804                fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
 805
 806        return 1;
 807}
 808
 809static int
 810cifs_init_inode(struct inode *inode, void *opaque)
 811{
 812        struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
 813
 814        CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
 815        CIFS_I(inode)->createtime = fattr->cf_createtime;
 816        return 0;
 817}
 818
 819/*
 820 * walk dentry list for an inode and report whether it has aliases that
 821 * are hashed. We use this to determine if a directory inode can actually
 822 * be used.
 823 */
 824static bool
 825inode_has_hashed_dentries(struct inode *inode)
 826{
 827        struct dentry *dentry;
 828
 829        spin_lock(&inode->i_lock);
 830        hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
 831                if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
 832                        spin_unlock(&inode->i_lock);
 833                        return true;
 834                }
 835        }
 836        spin_unlock(&inode->i_lock);
 837        return false;
 838}
 839
 840/* Given fattrs, get a corresponding inode */
 841struct inode *
 842cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
 843{
 844        unsigned long hash;
 845        struct inode *inode;
 846
 847retry_iget5_locked:
 848        cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
 849
 850        /* hash down to 32-bits on 32-bit arch */
 851        hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
 852
 853        inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
 854        if (inode) {
 855                /* was there a potentially problematic inode collision? */
 856                if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
 857                        fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
 858
 859                        if (inode_has_hashed_dentries(inode)) {
 860                                cifs_autodisable_serverino(CIFS_SB(sb));
 861                                iput(inode);
 862                                fattr->cf_uniqueid = iunique(sb, ROOT_I);
 863                                goto retry_iget5_locked;
 864                        }
 865                }
 866
 867                cifs_fattr_to_inode(inode, fattr);
 868                if (sb->s_flags & MS_NOATIME)
 869                        inode->i_flags |= S_NOATIME | S_NOCMTIME;
 870                if (inode->i_state & I_NEW) {
 871                        inode->i_ino = hash;
 872                        if (S_ISREG(inode->i_mode))
 873                                inode->i_data.backing_dev_info = sb->s_bdi;
 874#ifdef CONFIG_CIFS_FSCACHE
 875                        /* initialize per-inode cache cookie pointer */
 876                        CIFS_I(inode)->fscache = NULL;
 877#endif
 878                        unlock_new_inode(inode);
 879                }
 880        }
 881
 882        return inode;
 883}
 884
 885/* gets root inode */
 886struct inode *cifs_root_iget(struct super_block *sb)
 887{
 888        unsigned int xid;
 889        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 890        struct inode *inode = NULL;
 891        long rc;
 892        struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 893
 894        xid = get_xid();
 895        if (tcon->unix_ext)
 896                rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
 897        else
 898                rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
 899
 900        if (!inode) {
 901                inode = ERR_PTR(rc);
 902                goto out;
 903        }
 904
 905#ifdef CONFIG_CIFS_FSCACHE
 906        /* populate tcon->resource_id */
 907        tcon->resource_id = CIFS_I(inode)->uniqueid;
 908#endif
 909
 910        if (rc && tcon->ipc) {
 911                cifs_dbg(FYI, "ipc connection - fake read inode\n");
 912                spin_lock(&inode->i_lock);
 913                inode->i_mode |= S_IFDIR;
 914                set_nlink(inode, 2);
 915                inode->i_op = &cifs_ipc_inode_ops;
 916                inode->i_fop = &simple_dir_operations;
 917                inode->i_uid = cifs_sb->mnt_uid;
 918                inode->i_gid = cifs_sb->mnt_gid;
 919                spin_unlock(&inode->i_lock);
 920        } else if (rc) {
 921                iget_failed(inode);
 922                inode = ERR_PTR(rc);
 923        }
 924
 925out:
 926        /* can not call macro free_xid here since in a void func
 927         * TODO: This is no longer true
 928         */
 929        _free_xid(xid);
 930        return inode;
 931}
 932
 933int
 934cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
 935                   char *full_path, __u32 dosattr)
 936{
 937        bool set_time = false;
 938        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 939        struct TCP_Server_Info *server;
 940        FILE_BASIC_INFO info_buf;
 941
 942        if (attrs == NULL)
 943                return -EINVAL;
 944
 945        server = cifs_sb_master_tcon(cifs_sb)->ses->server;
 946        if (!server->ops->set_file_info)
 947                return -ENOSYS;
 948
 949        if (attrs->ia_valid & ATTR_ATIME) {
 950                set_time = true;
 951                info_buf.LastAccessTime =
 952                        cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
 953        } else
 954                info_buf.LastAccessTime = 0;
 955
 956        if (attrs->ia_valid & ATTR_MTIME) {
 957                set_time = true;
 958                info_buf.LastWriteTime =
 959                    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
 960        } else
 961                info_buf.LastWriteTime = 0;
 962
 963        /*
 964         * Samba throws this field away, but windows may actually use it.
 965         * Do not set ctime unless other time stamps are changed explicitly
 966         * (i.e. by utimes()) since we would then have a mix of client and
 967         * server times.
 968         */
 969        if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
 970                cifs_dbg(FYI, "CIFS - CTIME changed\n");
 971                info_buf.ChangeTime =
 972                    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
 973        } else
 974                info_buf.ChangeTime = 0;
 975
 976        info_buf.CreationTime = 0;      /* don't change */
 977        info_buf.Attributes = cpu_to_le32(dosattr);
 978
 979        return server->ops->set_file_info(inode, full_path, &info_buf, xid);
 980}
 981
 982/*
 983 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
 984 * and rename it to a random name that hopefully won't conflict with
 985 * anything else.
 986 */
 987int
 988cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
 989                           const unsigned int xid)
 990{
 991        int oplock = 0;
 992        int rc;
 993        __u16 netfid;
 994        struct inode *inode = dentry->d_inode;
 995        struct cifsInodeInfo *cifsInode = CIFS_I(inode);
 996        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 997        struct tcon_link *tlink;
 998        struct cifs_tcon *tcon;
 999        __u32 dosattr, origattr;
1000        FILE_BASIC_INFO *info_buf = NULL;
1001
1002        tlink = cifs_sb_tlink(cifs_sb);
1003        if (IS_ERR(tlink))
1004                return PTR_ERR(tlink);
1005        tcon = tlink_tcon(tlink);
1006
1007        /*
1008         * We cannot rename the file if the server doesn't support
1009         * CAP_INFOLEVEL_PASSTHRU
1010         */
1011        if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1012                rc = -EBUSY;
1013                goto out;
1014        }
1015
1016        rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1017                         DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1018                         &netfid, &oplock, NULL, cifs_sb->local_nls,
1019                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1020        if (rc != 0)
1021                goto out;
1022
1023        origattr = cifsInode->cifsAttrs;
1024        if (origattr == 0)
1025                origattr |= ATTR_NORMAL;
1026
1027        dosattr = origattr & ~ATTR_READONLY;
1028        if (dosattr == 0)
1029                dosattr |= ATTR_NORMAL;
1030        dosattr |= ATTR_HIDDEN;
1031
1032        /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1033        if (dosattr != origattr) {
1034                info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1035                if (info_buf == NULL) {
1036                        rc = -ENOMEM;
1037                        goto out_close;
1038                }
1039                info_buf->Attributes = cpu_to_le32(dosattr);
1040                rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1041                                        current->tgid);
1042                /* although we would like to mark the file hidden
1043                   if that fails we will still try to rename it */
1044                if (!rc)
1045                        cifsInode->cifsAttrs = dosattr;
1046                else
1047                        dosattr = origattr; /* since not able to change them */
1048        }
1049
1050        /* rename the file */
1051        rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1052                                   cifs_sb->mnt_cifs_flags &
1053                                            CIFS_MOUNT_MAP_SPECIAL_CHR);
1054        if (rc != 0) {
1055                rc = -EBUSY;
1056                goto undo_setattr;
1057        }
1058
1059        /* try to set DELETE_ON_CLOSE */
1060        if (!cifsInode->delete_pending) {
1061                rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1062                                               current->tgid);
1063                /*
1064                 * some samba versions return -ENOENT when we try to set the
1065                 * file disposition here. Likely a samba bug, but work around
1066                 * it for now. This means that some cifsXXX files may hang
1067                 * around after they shouldn't.
1068                 *
1069                 * BB: remove this hack after more servers have the fix
1070                 */
1071                if (rc == -ENOENT)
1072                        rc = 0;
1073                else if (rc != 0) {
1074                        rc = -EBUSY;
1075                        goto undo_rename;
1076                }
1077                cifsInode->delete_pending = true;
1078        }
1079
1080out_close:
1081        CIFSSMBClose(xid, tcon, netfid);
1082out:
1083        kfree(info_buf);
1084        cifs_put_tlink(tlink);
1085        return rc;
1086
1087        /*
1088         * reset everything back to the original state. Don't bother
1089         * dealing with errors here since we can't do anything about
1090         * them anyway.
1091         */
1092undo_rename:
1093        CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1094                                cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1095                                            CIFS_MOUNT_MAP_SPECIAL_CHR);
1096undo_setattr:
1097        if (dosattr != origattr) {
1098                info_buf->Attributes = cpu_to_le32(origattr);
1099                if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1100                                        current->tgid))
1101                        cifsInode->cifsAttrs = origattr;
1102        }
1103
1104        goto out_close;
1105}
1106
1107/* copied from fs/nfs/dir.c with small changes */
1108static void
1109cifs_drop_nlink(struct inode *inode)
1110{
1111        spin_lock(&inode->i_lock);
1112        if (inode->i_nlink > 0)
1113                drop_nlink(inode);
1114        spin_unlock(&inode->i_lock);
1115}
1116
1117/*
1118 * If dentry->d_inode is null (usually meaning the cached dentry
1119 * is a negative dentry) then we would attempt a standard SMB delete, but
1120 * if that fails we can not attempt the fall back mechanisms on EACCESS
1121 * but will return the EACCESS to the caller. Note that the VFS does not call
1122 * unlink on negative dentries currently.
1123 */
1124int cifs_unlink(struct inode *dir, struct dentry *dentry)
1125{
1126        int rc = 0;
1127        unsigned int xid;
1128        char *full_path = NULL;
1129        struct inode *inode = dentry->d_inode;
1130        struct cifsInodeInfo *cifs_inode;
1131        struct super_block *sb = dir->i_sb;
1132        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1133        struct tcon_link *tlink;
1134        struct cifs_tcon *tcon;
1135        struct TCP_Server_Info *server;
1136        struct iattr *attrs = NULL;
1137        __u32 dosattr = 0, origattr = 0;
1138
1139        cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1140
1141        tlink = cifs_sb_tlink(cifs_sb);
1142        if (IS_ERR(tlink))
1143                return PTR_ERR(tlink);
1144        tcon = tlink_tcon(tlink);
1145        server = tcon->ses->server;
1146
1147        xid = get_xid();
1148
1149        /* Unlink can be called from rename so we can not take the
1150         * sb->s_vfs_rename_mutex here */
1151        full_path = build_path_from_dentry(dentry);
1152        if (full_path == NULL) {
1153                rc = -ENOMEM;
1154                goto unlink_out;
1155        }
1156
1157        if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1158                                le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1159                rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1160                        SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1161                        cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1162                cifs_dbg(FYI, "posix del rc %d\n", rc);
1163                if ((rc == 0) || (rc == -ENOENT))
1164                        goto psx_del_no_retry;
1165        }
1166
1167retry_std_delete:
1168        if (!server->ops->unlink) {
1169                rc = -ENOSYS;
1170                goto psx_del_no_retry;
1171        }
1172
1173        rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1174
1175psx_del_no_retry:
1176        if (!rc) {
1177                if (inode)
1178                        cifs_drop_nlink(inode);
1179        } else if (rc == -ENOENT) {
1180                d_drop(dentry);
1181        } else if (rc == -EBUSY) {
1182                if (server->ops->rename_pending_delete) {
1183                        rc = server->ops->rename_pending_delete(full_path,
1184                                                                dentry, xid);
1185                        if (rc == 0)
1186                                cifs_drop_nlink(inode);
1187                }
1188        } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1189                attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1190                if (attrs == NULL) {
1191                        rc = -ENOMEM;
1192                        goto out_reval;
1193                }
1194
1195                /* try to reset dos attributes */
1196                cifs_inode = CIFS_I(inode);
1197                origattr = cifs_inode->cifsAttrs;
1198                if (origattr == 0)
1199                        origattr |= ATTR_NORMAL;
1200                dosattr = origattr & ~ATTR_READONLY;
1201                if (dosattr == 0)
1202                        dosattr |= ATTR_NORMAL;
1203                dosattr |= ATTR_HIDDEN;
1204
1205                rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1206                if (rc != 0)
1207                        goto out_reval;
1208
1209                goto retry_std_delete;
1210        }
1211
1212        /* undo the setattr if we errored out and it's needed */
1213        if (rc != 0 && dosattr != 0)
1214                cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1215
1216out_reval:
1217        if (inode) {
1218                cifs_inode = CIFS_I(inode);
1219                cifs_inode->time = 0;   /* will force revalidate to get info
1220                                           when needed */
1221                inode->i_ctime = current_fs_time(sb);
1222        }
1223        dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1224        cifs_inode = CIFS_I(dir);
1225        CIFS_I(dir)->time = 0;  /* force revalidate of dir as well */
1226unlink_out:
1227        kfree(full_path);
1228        kfree(attrs);
1229        free_xid(xid);
1230        cifs_put_tlink(tlink);
1231        return rc;
1232}
1233
1234static int
1235cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1236                 const char *full_path, struct cifs_sb_info *cifs_sb,
1237                 struct cifs_tcon *tcon, const unsigned int xid)
1238{
1239        int rc = 0;
1240        struct inode *inode = NULL;
1241
1242        if (tcon->unix_ext)
1243                rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1244                                              xid);
1245        else
1246                rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1247                                         xid, NULL);
1248
1249        if (rc)
1250                return rc;
1251
1252        /*
1253         * setting nlink not necessary except in cases where we failed to get it
1254         * from the server or was set bogus. Also, since this is a brand new
1255         * inode, no need to grab the i_lock before setting the i_nlink.
1256         */
1257        if (inode->i_nlink < 2)
1258                set_nlink(inode, 2);
1259        mode &= ~current_umask();
1260        /* must turn on setgid bit if parent dir has it */
1261        if (parent->i_mode & S_ISGID)
1262                mode |= S_ISGID;
1263
1264        if (tcon->unix_ext) {
1265                struct cifs_unix_set_info_args args = {
1266                        .mode   = mode,
1267                        .ctime  = NO_CHANGE_64,
1268                        .atime  = NO_CHANGE_64,
1269                        .mtime  = NO_CHANGE_64,
1270                        .device = 0,
1271                };
1272                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1273                        args.uid = current_fsuid();
1274                        if (parent->i_mode & S_ISGID)
1275                                args.gid = parent->i_gid;
1276                        else
1277                                args.gid = current_fsgid();
1278                } else {
1279                        args.uid = INVALID_UID; /* no change */
1280                        args.gid = INVALID_GID; /* no change */
1281                }
1282                CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1283                                       cifs_sb->local_nls,
1284                                       cifs_sb->mnt_cifs_flags &
1285                                       CIFS_MOUNT_MAP_SPECIAL_CHR);
1286        } else {
1287                struct TCP_Server_Info *server = tcon->ses->server;
1288                if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1289                    (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1290                        server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1291                                                   tcon, xid);
1292                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1293                        inode->i_mode = (mode | S_IFDIR);
1294
1295                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1296                        inode->i_uid = current_fsuid();
1297                        if (inode->i_mode & S_ISGID)
1298                                inode->i_gid = parent->i_gid;
1299                        else
1300                                inode->i_gid = current_fsgid();
1301                }
1302        }
1303        d_instantiate(dentry, inode);
1304        return rc;
1305}
1306
1307static int
1308cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1309                 const char *full_path, struct cifs_sb_info *cifs_sb,
1310                 struct cifs_tcon *tcon, const unsigned int xid)
1311{
1312        int rc = 0;
1313        u32 oplock = 0;
1314        FILE_UNIX_BASIC_INFO *info = NULL;
1315        struct inode *newinode = NULL;
1316        struct cifs_fattr fattr;
1317
1318        info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1319        if (info == NULL) {
1320                rc = -ENOMEM;
1321                goto posix_mkdir_out;
1322        }
1323
1324        mode &= ~current_umask();
1325        rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1326                             NULL /* netfid */, info, &oplock, full_path,
1327                             cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1328                             CIFS_MOUNT_MAP_SPECIAL_CHR);
1329        if (rc == -EOPNOTSUPP)
1330                goto posix_mkdir_out;
1331        else if (rc) {
1332                cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1333                d_drop(dentry);
1334                goto posix_mkdir_out;
1335        }
1336
1337        if (info->Type == cpu_to_le32(-1))
1338                /* no return info, go query for it */
1339                goto posix_mkdir_get_info;
1340        /*
1341         * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1342         * need to set uid/gid.
1343         */
1344
1345        cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1346        cifs_fill_uniqueid(inode->i_sb, &fattr);
1347        newinode = cifs_iget(inode->i_sb, &fattr);
1348        if (!newinode)
1349                goto posix_mkdir_get_info;
1350
1351        d_instantiate(dentry, newinode);
1352
1353#ifdef CONFIG_CIFS_DEBUG2
1354        cifs_dbg(FYI, "instantiated dentry %p %s to inode %p\n",
1355                 dentry, dentry->d_name.name, newinode);
1356
1357        if (newinode->i_nlink != 2)
1358                cifs_dbg(FYI, "unexpected number of links %d\n",
1359                         newinode->i_nlink);
1360#endif
1361
1362posix_mkdir_out:
1363        kfree(info);
1364        return rc;
1365posix_mkdir_get_info:
1366        rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1367                              xid);
1368        goto posix_mkdir_out;
1369}
1370
1371int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1372{
1373        int rc = 0;
1374        unsigned int xid;
1375        struct cifs_sb_info *cifs_sb;
1376        struct tcon_link *tlink;
1377        struct cifs_tcon *tcon;
1378        struct TCP_Server_Info *server;
1379        char *full_path;
1380
1381        cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1382                 mode, inode);
1383
1384        cifs_sb = CIFS_SB(inode->i_sb);
1385        tlink = cifs_sb_tlink(cifs_sb);
1386        if (IS_ERR(tlink))
1387                return PTR_ERR(tlink);
1388        tcon = tlink_tcon(tlink);
1389
1390        xid = get_xid();
1391
1392        full_path = build_path_from_dentry(direntry);
1393        if (full_path == NULL) {
1394                rc = -ENOMEM;
1395                goto mkdir_out;
1396        }
1397
1398        if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1399                                le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1400                rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1401                                      tcon, xid);
1402                if (rc != -EOPNOTSUPP)
1403                        goto mkdir_out;
1404        }
1405
1406        server = tcon->ses->server;
1407
1408        if (!server->ops->mkdir) {
1409                rc = -ENOSYS;
1410                goto mkdir_out;
1411        }
1412
1413        /* BB add setting the equivalent of mode via CreateX w/ACLs */
1414        rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1415        if (rc) {
1416                cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1417                d_drop(direntry);
1418                goto mkdir_out;
1419        }
1420
1421        rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1422                              xid);
1423mkdir_out:
1424        /*
1425         * Force revalidate to get parent dir info when needed since cached
1426         * attributes are invalid now.
1427         */
1428        CIFS_I(inode)->time = 0;
1429        kfree(full_path);
1430        free_xid(xid);
1431        cifs_put_tlink(tlink);
1432        return rc;
1433}
1434
1435int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1436{
1437        int rc = 0;
1438        unsigned int xid;
1439        struct cifs_sb_info *cifs_sb;
1440        struct tcon_link *tlink;
1441        struct cifs_tcon *tcon;
1442        struct TCP_Server_Info *server;
1443        char *full_path = NULL;
1444        struct cifsInodeInfo *cifsInode;
1445
1446        cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1447
1448        xid = get_xid();
1449
1450        full_path = build_path_from_dentry(direntry);
1451        if (full_path == NULL) {
1452                rc = -ENOMEM;
1453                goto rmdir_exit;
1454        }
1455
1456        cifs_sb = CIFS_SB(inode->i_sb);
1457        tlink = cifs_sb_tlink(cifs_sb);
1458        if (IS_ERR(tlink)) {
1459                rc = PTR_ERR(tlink);
1460                goto rmdir_exit;
1461        }
1462        tcon = tlink_tcon(tlink);
1463        server = tcon->ses->server;
1464
1465        if (!server->ops->rmdir) {
1466                rc = -ENOSYS;
1467                cifs_put_tlink(tlink);
1468                goto rmdir_exit;
1469        }
1470
1471        rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1472        cifs_put_tlink(tlink);
1473
1474        if (!rc) {
1475                spin_lock(&direntry->d_inode->i_lock);
1476                i_size_write(direntry->d_inode, 0);
1477                clear_nlink(direntry->d_inode);
1478                spin_unlock(&direntry->d_inode->i_lock);
1479        }
1480
1481        cifsInode = CIFS_I(direntry->d_inode);
1482        /* force revalidate to go get info when needed */
1483        cifsInode->time = 0;
1484
1485        cifsInode = CIFS_I(inode);
1486        /*
1487         * Force revalidate to get parent dir info when needed since cached
1488         * attributes are invalid now.
1489         */
1490        cifsInode->time = 0;
1491
1492        direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1493                current_fs_time(inode->i_sb);
1494
1495rmdir_exit:
1496        kfree(full_path);
1497        free_xid(xid);
1498        return rc;
1499}
1500
1501static int
1502cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1503               const char *from_path, struct dentry *to_dentry,
1504               const char *to_path)
1505{
1506        struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1507        struct tcon_link *tlink;
1508        struct cifs_tcon *tcon;
1509        struct TCP_Server_Info *server;
1510        __u16 srcfid;
1511        int oplock, rc;
1512
1513        tlink = cifs_sb_tlink(cifs_sb);
1514        if (IS_ERR(tlink))
1515                return PTR_ERR(tlink);
1516        tcon = tlink_tcon(tlink);
1517        server = tcon->ses->server;
1518
1519        if (!server->ops->rename)
1520                return -ENOSYS;
1521
1522        /* try path-based rename first */
1523        rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1524
1525        /*
1526         * Don't bother with rename by filehandle unless file is busy and
1527         * source. Note that cross directory moves do not work with
1528         * rename by filehandle to various Windows servers.
1529         */
1530        if (rc == 0 || rc != -EBUSY)
1531                goto do_rename_exit;
1532
1533        /* open-file renames don't work across directories */
1534        if (to_dentry->d_parent != from_dentry->d_parent)
1535                goto do_rename_exit;
1536
1537        /* open the file to be renamed -- we need DELETE perms */
1538        rc = CIFSSMBOpen(xid, tcon, from_path, FILE_OPEN, DELETE,
1539                         CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1540                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1541                                CIFS_MOUNT_MAP_SPECIAL_CHR);
1542        if (rc == 0) {
1543                rc = CIFSSMBRenameOpenFile(xid, tcon, srcfid,
1544                                (const char *) to_dentry->d_name.name,
1545                                cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1546                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
1547                CIFSSMBClose(xid, tcon, srcfid);
1548        }
1549do_rename_exit:
1550        cifs_put_tlink(tlink);
1551        return rc;
1552}
1553
1554int
1555cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1556            struct inode *target_dir, struct dentry *target_dentry)
1557{
1558        char *from_name = NULL;
1559        char *to_name = NULL;
1560        struct cifs_sb_info *cifs_sb;
1561        struct tcon_link *tlink;
1562        struct cifs_tcon *tcon;
1563        FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1564        FILE_UNIX_BASIC_INFO *info_buf_target;
1565        unsigned int xid;
1566        int rc, tmprc;
1567
1568        cifs_sb = CIFS_SB(source_dir->i_sb);
1569        tlink = cifs_sb_tlink(cifs_sb);
1570        if (IS_ERR(tlink))
1571                return PTR_ERR(tlink);
1572        tcon = tlink_tcon(tlink);
1573
1574        xid = get_xid();
1575
1576        /*
1577         * we already have the rename sem so we do not need to
1578         * grab it again here to protect the path integrity
1579         */
1580        from_name = build_path_from_dentry(source_dentry);
1581        if (from_name == NULL) {
1582                rc = -ENOMEM;
1583                goto cifs_rename_exit;
1584        }
1585
1586        to_name = build_path_from_dentry(target_dentry);
1587        if (to_name == NULL) {
1588                rc = -ENOMEM;
1589                goto cifs_rename_exit;
1590        }
1591
1592        rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1593                            to_name);
1594
1595        if (rc == -EEXIST && tcon->unix_ext) {
1596                /*
1597                 * Are src and dst hardlinks of same inode? We can only tell
1598                 * with unix extensions enabled.
1599                 */
1600                info_buf_source =
1601                        kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1602                                        GFP_KERNEL);
1603                if (info_buf_source == NULL) {
1604                        rc = -ENOMEM;
1605                        goto cifs_rename_exit;
1606                }
1607
1608                info_buf_target = info_buf_source + 1;
1609                tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1610                                             info_buf_source,
1611                                             cifs_sb->local_nls,
1612                                             cifs_sb->mnt_cifs_flags &
1613                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
1614                if (tmprc != 0)
1615                        goto unlink_target;
1616
1617                tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1618                                             info_buf_target,
1619                                             cifs_sb->local_nls,
1620                                             cifs_sb->mnt_cifs_flags &
1621                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
1622
1623                if (tmprc == 0 && (info_buf_source->UniqueId ==
1624                                   info_buf_target->UniqueId)) {
1625                        /* same file, POSIX says that this is a noop */
1626                        rc = 0;
1627                        goto cifs_rename_exit;
1628                }
1629        }
1630        /*
1631         * else ... BB we could add the same check for Windows by
1632         * checking the UniqueId via FILE_INTERNAL_INFO
1633         */
1634
1635unlink_target:
1636        /* Try unlinking the target dentry if it's not negative */
1637        if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1638                tmprc = cifs_unlink(target_dir, target_dentry);
1639                if (tmprc)
1640                        goto cifs_rename_exit;
1641                rc = cifs_do_rename(xid, source_dentry, from_name,
1642                                    target_dentry, to_name);
1643        }
1644
1645cifs_rename_exit:
1646        kfree(info_buf_source);
1647        kfree(from_name);
1648        kfree(to_name);
1649        free_xid(xid);
1650        cifs_put_tlink(tlink);
1651        return rc;
1652}
1653
1654static bool
1655cifs_inode_needs_reval(struct inode *inode)
1656{
1657        struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1658        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1659
1660        if (cifs_i->clientCanCacheRead)
1661                return false;
1662
1663        if (!lookupCacheEnabled)
1664                return true;
1665
1666        if (cifs_i->time == 0)
1667                return true;
1668
1669        if (!time_in_range(jiffies, cifs_i->time,
1670                                cifs_i->time + cifs_sb->actimeo))
1671                return true;
1672
1673        /* hardlinked files w/ noserverino get "special" treatment */
1674        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1675            S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1676                return true;
1677
1678        return false;
1679}
1680
1681/*
1682 * Zap the cache. Called when invalid_mapping flag is set.
1683 */
1684int
1685cifs_invalidate_mapping(struct inode *inode)
1686{
1687        int rc = 0;
1688        struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1689
1690        cifs_i->invalid_mapping = false;
1691
1692        if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1693                rc = invalidate_inode_pages2(inode->i_mapping);
1694                if (rc) {
1695                        cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1696                                 __func__, inode);
1697                        cifs_i->invalid_mapping = true;
1698                }
1699        }
1700
1701        cifs_fscache_reset_inode_cookie(inode);
1702        return rc;
1703}
1704
1705int cifs_revalidate_file_attr(struct file *filp)
1706{
1707        int rc = 0;
1708        struct inode *inode = file_inode(filp);
1709        struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1710
1711        if (!cifs_inode_needs_reval(inode))
1712                return rc;
1713
1714        if (tlink_tcon(cfile->tlink)->unix_ext)
1715                rc = cifs_get_file_info_unix(filp);
1716        else
1717                rc = cifs_get_file_info(filp);
1718
1719        return rc;
1720}
1721
1722int cifs_revalidate_dentry_attr(struct dentry *dentry)
1723{
1724        unsigned int xid;
1725        int rc = 0;
1726        struct inode *inode = dentry->d_inode;
1727        struct super_block *sb = dentry->d_sb;
1728        char *full_path = NULL;
1729
1730        if (inode == NULL)
1731                return -ENOENT;
1732
1733        if (!cifs_inode_needs_reval(inode))
1734                return rc;
1735
1736        xid = get_xid();
1737
1738        /* can not safely grab the rename sem here if rename calls revalidate
1739           since that would deadlock */
1740        full_path = build_path_from_dentry(dentry);
1741        if (full_path == NULL) {
1742                rc = -ENOMEM;
1743                goto out;
1744        }
1745
1746        cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1747                 full_path, inode, inode->i_count.counter,
1748                 dentry, dentry->d_time, jiffies);
1749
1750        if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1751                rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1752        else
1753                rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1754                                         xid, NULL);
1755
1756out:
1757        kfree(full_path);
1758        free_xid(xid);
1759        return rc;
1760}
1761
1762int cifs_revalidate_file(struct file *filp)
1763{
1764        int rc;
1765        struct inode *inode = file_inode(filp);
1766
1767        rc = cifs_revalidate_file_attr(filp);
1768        if (rc)
1769                return rc;
1770
1771        if (CIFS_I(inode)->invalid_mapping)
1772                rc = cifs_invalidate_mapping(inode);
1773        return rc;
1774}
1775
1776/* revalidate a dentry's inode attributes */
1777int cifs_revalidate_dentry(struct dentry *dentry)
1778{
1779        int rc;
1780        struct inode *inode = dentry->d_inode;
1781
1782        rc = cifs_revalidate_dentry_attr(dentry);
1783        if (rc)
1784                return rc;
1785
1786        if (CIFS_I(inode)->invalid_mapping)
1787                rc = cifs_invalidate_mapping(inode);
1788        return rc;
1789}
1790
1791int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1792                 struct kstat *stat)
1793{
1794        struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1795        struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1796        struct inode *inode = dentry->d_inode;
1797        int rc;
1798
1799        /*
1800         * We need to be sure that all dirty pages are written and the server
1801         * has actual ctime, mtime and file length.
1802         */
1803        if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1804            inode->i_mapping->nrpages != 0) {
1805                rc = filemap_fdatawait(inode->i_mapping);
1806                if (rc) {
1807                        mapping_set_error(inode->i_mapping, rc);
1808                        return rc;
1809                }
1810        }
1811
1812        rc = cifs_revalidate_dentry_attr(dentry);
1813        if (rc)
1814                return rc;
1815
1816        generic_fillattr(inode, stat);
1817        stat->blksize = CIFS_MAX_MSGSIZE;
1818        stat->ino = CIFS_I(inode)->uniqueid;
1819
1820        /*
1821         * If on a multiuser mount without unix extensions or cifsacl being
1822         * enabled, and the admin hasn't overridden them, set the ownership
1823         * to the fsuid/fsgid of the current process.
1824         */
1825        if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1826            !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1827            !tcon->unix_ext) {
1828                if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1829                        stat->uid = current_fsuid();
1830                if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1831                        stat->gid = current_fsgid();
1832        }
1833        return rc;
1834}
1835
1836static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1837{
1838        pgoff_t index = from >> PAGE_CACHE_SHIFT;
1839        unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1840        struct page *page;
1841        int rc = 0;
1842
1843        page = grab_cache_page(mapping, index);
1844        if (!page)
1845                return -ENOMEM;
1846
1847        zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1848        unlock_page(page);
1849        page_cache_release(page);
1850        return rc;
1851}
1852
1853static void cifs_setsize(struct inode *inode, loff_t offset)
1854{
1855        loff_t oldsize;
1856
1857        spin_lock(&inode->i_lock);
1858        oldsize = inode->i_size;
1859        i_size_write(inode, offset);
1860        spin_unlock(&inode->i_lock);
1861
1862        truncate_pagecache(inode, oldsize, offset);
1863}
1864
1865static int
1866cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1867                   unsigned int xid, char *full_path)
1868{
1869        int rc;
1870        struct cifsFileInfo *open_file;
1871        struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1872        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1873        struct tcon_link *tlink = NULL;
1874        struct cifs_tcon *tcon = NULL;
1875        struct TCP_Server_Info *server;
1876        struct cifs_io_parms io_parms;
1877
1878        /*
1879         * To avoid spurious oplock breaks from server, in the case of
1880         * inodes that we already have open, avoid doing path based
1881         * setting of file size if we can do it by handle.
1882         * This keeps our caching token (oplock) and avoids timeouts
1883         * when the local oplock break takes longer to flush
1884         * writebehind data than the SMB timeout for the SetPathInfo
1885         * request would allow
1886         */
1887        open_file = find_writable_file(cifsInode, true);
1888        if (open_file) {
1889                tcon = tlink_tcon(open_file->tlink);
1890                server = tcon->ses->server;
1891                if (server->ops->set_file_size)
1892                        rc = server->ops->set_file_size(xid, tcon, open_file,
1893                                                        attrs->ia_size, false);
1894                else
1895                        rc = -ENOSYS;
1896                cifsFileInfo_put(open_file);
1897                cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
1898                if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1899                        unsigned int bytes_written;
1900
1901                        io_parms.netfid = open_file->fid.netfid;
1902                        io_parms.pid = open_file->pid;
1903                        io_parms.tcon = tcon;
1904                        io_parms.offset = 0;
1905                        io_parms.length = attrs->ia_size;
1906                        rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1907                                          NULL, NULL, 1);
1908                        cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
1909                }
1910        } else
1911                rc = -EINVAL;
1912
1913        if (!rc)
1914                goto set_size_out;
1915
1916        if (tcon == NULL) {
1917                tlink = cifs_sb_tlink(cifs_sb);
1918                if (IS_ERR(tlink))
1919                        return PTR_ERR(tlink);
1920                tcon = tlink_tcon(tlink);
1921                server = tcon->ses->server;
1922        }
1923
1924        /*
1925         * Set file size by pathname rather than by handle either because no
1926         * valid, writeable file handle for it was found or because there was
1927         * an error setting it by handle.
1928         */
1929        if (server->ops->set_path_size)
1930                rc = server->ops->set_path_size(xid, tcon, full_path,
1931                                                attrs->ia_size, cifs_sb, false);
1932        else
1933                rc = -ENOSYS;
1934        cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
1935        if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1936                __u16 netfid;
1937                int oplock = 0;
1938
1939                rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
1940                                   GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
1941                                   &oplock, NULL, cifs_sb->local_nls,
1942                                   cifs_sb->mnt_cifs_flags &
1943                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
1944                if (rc == 0) {
1945                        unsigned int bytes_written;
1946
1947                        io_parms.netfid = netfid;
1948                        io_parms.pid = current->tgid;
1949                        io_parms.tcon = tcon;
1950                        io_parms.offset = 0;
1951                        io_parms.length = attrs->ia_size;
1952                        rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
1953                                          NULL,  1);
1954                        cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
1955                        CIFSSMBClose(xid, tcon, netfid);
1956                }
1957        }
1958        if (tlink)
1959                cifs_put_tlink(tlink);
1960
1961set_size_out:
1962        if (rc == 0) {
1963                cifsInode->server_eof = attrs->ia_size;
1964                cifs_setsize(inode, attrs->ia_size);
1965                cifs_truncate_page(inode->i_mapping, inode->i_size);
1966        }
1967
1968        return rc;
1969}
1970
1971static int
1972cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1973{
1974        int rc;
1975        unsigned int xid;
1976        char *full_path = NULL;
1977        struct inode *inode = direntry->d_inode;
1978        struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1979        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1980        struct tcon_link *tlink;
1981        struct cifs_tcon *pTcon;
1982        struct cifs_unix_set_info_args *args = NULL;
1983        struct cifsFileInfo *open_file;
1984
1985        cifs_dbg(FYI, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
1986                 direntry->d_name.name, attrs->ia_valid);
1987
1988        xid = get_xid();
1989
1990        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1991                attrs->ia_valid |= ATTR_FORCE;
1992
1993        rc = inode_change_ok(inode, attrs);
1994        if (rc < 0)
1995                goto out;
1996
1997        full_path = build_path_from_dentry(direntry);
1998        if (full_path == NULL) {
1999                rc = -ENOMEM;
2000                goto out;
2001        }
2002
2003        /*
2004         * Attempt to flush data before changing attributes. We need to do
2005         * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2006         * ownership or mode then we may also need to do this. Here, we take
2007         * the safe way out and just do the flush on all setattr requests. If
2008         * the flush returns error, store it to report later and continue.
2009         *
2010         * BB: This should be smarter. Why bother flushing pages that
2011         * will be truncated anyway? Also, should we error out here if
2012         * the flush returns error?
2013         */
2014        rc = filemap_write_and_wait(inode->i_mapping);
2015        mapping_set_error(inode->i_mapping, rc);
2016        rc = 0;
2017
2018        if (attrs->ia_valid & ATTR_SIZE) {
2019                rc = cifs_set_file_size(inode, attrs, xid, full_path);
2020                if (rc != 0)
2021                        goto out;
2022        }
2023
2024        /* skip mode change if it's just for clearing setuid/setgid */
2025        if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2026                attrs->ia_valid &= ~ATTR_MODE;
2027
2028        args = kmalloc(sizeof(*args), GFP_KERNEL);
2029        if (args == NULL) {
2030                rc = -ENOMEM;
2031                goto out;
2032        }
2033
2034        /* set up the struct */
2035        if (attrs->ia_valid & ATTR_MODE)
2036                args->mode = attrs->ia_mode;
2037        else
2038                args->mode = NO_CHANGE_64;
2039
2040        if (attrs->ia_valid & ATTR_UID)
2041                args->uid = attrs->ia_uid;
2042        else
2043                args->uid = INVALID_UID; /* no change */
2044
2045        if (attrs->ia_valid & ATTR_GID)
2046                args->gid = attrs->ia_gid;
2047        else
2048                args->gid = INVALID_GID; /* no change */
2049
2050        if (attrs->ia_valid & ATTR_ATIME)
2051                args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2052        else
2053                args->atime = NO_CHANGE_64;
2054
2055        if (attrs->ia_valid & ATTR_MTIME)
2056                args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2057        else
2058                args->mtime = NO_CHANGE_64;
2059
2060        if (attrs->ia_valid & ATTR_CTIME)
2061                args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2062        else
2063                args->ctime = NO_CHANGE_64;
2064
2065        args->device = 0;
2066        open_file = find_writable_file(cifsInode, true);
2067        if (open_file) {
2068                u16 nfid = open_file->fid.netfid;
2069                u32 npid = open_file->pid;
2070                pTcon = tlink_tcon(open_file->tlink);
2071                rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2072                cifsFileInfo_put(open_file);
2073        } else {
2074                tlink = cifs_sb_tlink(cifs_sb);
2075                if (IS_ERR(tlink)) {
2076                        rc = PTR_ERR(tlink);
2077                        goto out;
2078                }
2079                pTcon = tlink_tcon(tlink);
2080                rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2081                                    cifs_sb->local_nls,
2082                                    cifs_sb->mnt_cifs_flags &
2083                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
2084                cifs_put_tlink(tlink);
2085        }
2086
2087        if (rc)
2088                goto out;
2089
2090        if ((attrs->ia_valid & ATTR_SIZE) &&
2091            attrs->ia_size != i_size_read(inode))
2092                truncate_setsize(inode, attrs->ia_size);
2093
2094        setattr_copy(inode, attrs);
2095        mark_inode_dirty(inode);
2096
2097        /* force revalidate when any of these times are set since some
2098           of the fs types (eg ext3, fat) do not have fine enough
2099           time granularity to match protocol, and we do not have a
2100           a way (yet) to query the server fs's time granularity (and
2101           whether it rounds times down).
2102        */
2103        if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2104                cifsInode->time = 0;
2105out:
2106        kfree(args);
2107        kfree(full_path);
2108        free_xid(xid);
2109        return rc;
2110}
2111
2112static int
2113cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2114{
2115        unsigned int xid;
2116        kuid_t uid = INVALID_UID;
2117        kgid_t gid = INVALID_GID;
2118        struct inode *inode = direntry->d_inode;
2119        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2120        struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2121        char *full_path = NULL;
2122        int rc = -EACCES;
2123        __u32 dosattr = 0;
2124        __u64 mode = NO_CHANGE_64;
2125
2126        xid = get_xid();
2127
2128        cifs_dbg(FYI, "setattr on file %s attrs->iavalid 0x%x\n",
2129                 direntry->d_name.name, attrs->ia_valid);
2130
2131        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2132                attrs->ia_valid |= ATTR_FORCE;
2133
2134        rc = inode_change_ok(inode, attrs);
2135        if (rc < 0) {
2136                free_xid(xid);
2137                return rc;
2138        }
2139
2140        full_path = build_path_from_dentry(direntry);
2141        if (full_path == NULL) {
2142                rc = -ENOMEM;
2143                free_xid(xid);
2144                return rc;
2145        }
2146
2147        /*
2148         * Attempt to flush data before changing attributes. We need to do
2149         * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2150         * ownership or mode then we may also need to do this. Here, we take
2151         * the safe way out and just do the flush on all setattr requests. If
2152         * the flush returns error, store it to report later and continue.
2153         *
2154         * BB: This should be smarter. Why bother flushing pages that
2155         * will be truncated anyway? Also, should we error out here if
2156         * the flush returns error?
2157         */
2158        rc = filemap_write_and_wait(inode->i_mapping);
2159        mapping_set_error(inode->i_mapping, rc);
2160        rc = 0;
2161
2162        if (attrs->ia_valid & ATTR_SIZE) {
2163                rc = cifs_set_file_size(inode, attrs, xid, full_path);
2164                if (rc != 0)
2165                        goto cifs_setattr_exit;
2166        }
2167
2168        if (attrs->ia_valid & ATTR_UID)
2169                uid = attrs->ia_uid;
2170
2171        if (attrs->ia_valid & ATTR_GID)
2172                gid = attrs->ia_gid;
2173
2174#ifdef CONFIG_CIFS_ACL
2175        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2176                if (uid_valid(uid) || gid_valid(gid)) {
2177                        rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2178                                                        uid, gid);
2179                        if (rc) {
2180                                cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2181                                         __func__, rc);
2182                                goto cifs_setattr_exit;
2183                        }
2184                }
2185        } else
2186#endif /* CONFIG_CIFS_ACL */
2187        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2188                attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2189
2190        /* skip mode change if it's just for clearing setuid/setgid */
2191        if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2192                attrs->ia_valid &= ~ATTR_MODE;
2193
2194        if (attrs->ia_valid & ATTR_MODE) {
2195                mode = attrs->ia_mode;
2196                rc = 0;
2197#ifdef CONFIG_CIFS_ACL
2198                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2199                        rc = id_mode_to_cifs_acl(inode, full_path, mode,
2200                                                INVALID_UID, INVALID_GID);
2201                        if (rc) {
2202                                cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2203                                         __func__, rc);
2204                                goto cifs_setattr_exit;
2205                        }
2206                } else
2207#endif /* CONFIG_CIFS_ACL */
2208                if (((mode & S_IWUGO) == 0) &&
2209                    (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2210
2211                        dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2212
2213                        /* fix up mode if we're not using dynperm */
2214                        if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2215                                attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2216                } else if ((mode & S_IWUGO) &&
2217                           (cifsInode->cifsAttrs & ATTR_READONLY)) {
2218
2219                        dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2220                        /* Attributes of 0 are ignored */
2221                        if (dosattr == 0)
2222                                dosattr |= ATTR_NORMAL;
2223
2224                        /* reset local inode permissions to normal */
2225                        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2226                                attrs->ia_mode &= ~(S_IALLUGO);
2227                                if (S_ISDIR(inode->i_mode))
2228                                        attrs->ia_mode |=
2229                                                cifs_sb->mnt_dir_mode;
2230                                else
2231                                        attrs->ia_mode |=
2232                                                cifs_sb->mnt_file_mode;
2233                        }
2234                } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2235                        /* ignore mode change - ATTR_READONLY hasn't changed */
2236                        attrs->ia_valid &= ~ATTR_MODE;
2237                }
2238        }
2239
2240        if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2241            ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2242                rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2243                /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2244
2245                /* Even if error on time set, no sense failing the call if
2246                the server would set the time to a reasonable value anyway,
2247                and this check ensures that we are not being called from
2248                sys_utimes in which case we ought to fail the call back to
2249                the user when the server rejects the call */
2250                if ((rc) && (attrs->ia_valid &
2251                                (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2252                        rc = 0;
2253        }
2254
2255        /* do not need local check to inode_check_ok since the server does
2256           that */
2257        if (rc)
2258                goto cifs_setattr_exit;
2259
2260        if ((attrs->ia_valid & ATTR_SIZE) &&
2261            attrs->ia_size != i_size_read(inode))
2262                truncate_setsize(inode, attrs->ia_size);
2263
2264        setattr_copy(inode, attrs);
2265        mark_inode_dirty(inode);
2266
2267cifs_setattr_exit:
2268        kfree(full_path);
2269        free_xid(xid);
2270        return rc;
2271}
2272
2273int
2274cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2275{
2276        struct inode *inode = direntry->d_inode;
2277        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2278        struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2279
2280        if (pTcon->unix_ext)
2281                return cifs_setattr_unix(direntry, attrs);
2282
2283        return cifs_setattr_nounix(direntry, attrs);
2284
2285        /* BB: add cifs_setattr_legacy for really old servers */
2286}
2287
2288#if 0
2289void cifs_delete_inode(struct inode *inode)
2290{
2291        cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2292        /* may have to add back in if and when safe distributed caching of
2293           directories added e.g. via FindNotify */
2294}
2295#endif
2296
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.