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