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