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