git.oblomov.eu Git - linux-2.6/blob - fs/cifs/inode.c

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