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