SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/cifs/inode.c

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