4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
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.
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.
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
22 #include <linux/stat.h>
23 #include <linux/pagemap.h>
24 #include <asm/div64.h>
28 #include "cifsproto.h"
29 #include "cifs_debug.h"
30 #include "cifs_fs_sb.h"
33 static void cifs_set_ops(struct inode *inode, const bool is_dfs_referral)
35 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
37 switch (inode->i_mode & S_IFMT) {
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;
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;
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;
57 inode->i_data.a_ops = &cifs_addr_ops;
60 #ifdef CONFIG_CIFS_DFS_UPCALL
61 if (is_dfs_referral) {
62 inode->i_op = &cifs_dfs_referral_inode_operations;
64 #else /* NO DFS support, treat as a directory */
67 inode->i_op = &cifs_dir_inode_ops;
68 inode->i_fop = &cifs_dir_ops;
72 inode->i_op = &cifs_symlink_inode_ops;
75 init_special_inode(inode, inode->i_mode, inode->i_rdev);
80 static void cifs_unix_info_to_inode(struct inode *inode,
81 FILE_UNIX_BASIC_INFO *info, int force_uid_gid)
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);
88 inode->i_atime = cifs_NTtimeToUnix(info->LastAccessTime);
90 cifs_NTtimeToUnix(info->LastModificationTime);
91 inode->i_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
92 inode->i_mode = le64_to_cpu(info->Permissions);
95 * Since we set the inode type below we need to mask off
96 * to avoid strange results if bits set above.
98 inode->i_mode &= ~S_IFMT;
99 switch (le32_to_cpu(info->Type)) {
101 inode->i_mode |= S_IFREG;
104 inode->i_mode |= S_IFLNK;
107 inode->i_mode |= S_IFDIR;
110 inode->i_mode |= S_IFCHR;
111 inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
112 le64_to_cpu(info->DevMinor) & MINORMASK);
115 inode->i_mode |= S_IFBLK;
116 inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
117 le64_to_cpu(info->DevMinor) & MINORMASK);
120 inode->i_mode |= S_IFIFO;
123 inode->i_mode |= S_IFSOCK;
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)));
132 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) &&
134 inode->i_uid = cifs_sb->mnt_uid;
136 inode->i_uid = le64_to_cpu(info->Uid);
138 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) &&
140 inode->i_gid = cifs_sb->mnt_gid;
142 inode->i_gid = le64_to_cpu(info->Gid);
144 inode->i_nlink = le64_to_cpu(info->Nlinks);
146 cifsInfo->server_eof = end_of_file;
147 spin_lock(&inode->i_lock);
148 if (is_size_safe_to_change(cifsInfo, end_of_file)) {
150 * We can not safely change the file size here if the client
151 * is writing to it due to potential races.
153 i_size_write(inode, end_of_file);
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.
160 inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
162 spin_unlock(&inode->i_lock);
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)
171 static void fill_fake_finddataunix(FILE_UNIX_BASIC_INFO *pfnd_dat,
172 struct super_block *sb)
174 struct inode *pinode = NULL;
176 memset(pfnd_dat, 0, sizeof(FILE_UNIX_BASIC_INFO));
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);
191 pinode = sb->s_root->d_inode;
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);
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
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.
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.
217 cifs_new_inode(struct super_block *sb, __u64 *inum)
221 inode = new_inode(sb);
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()?
231 if (inum && (CIFS_SB(sb)->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM))
232 inode->i_ino = (unsigned long) *inum;
235 * must set this here instead of cifs_alloc_inode since VFS will
238 if (sb->s_flags & MS_NOATIME)
239 inode->i_flags |= S_NOATIME | S_NOCMTIME;
241 insert_inode_hash(inode);
246 int cifs_get_inode_info_unix(struct inode **pinode,
247 const unsigned char *full_path, struct super_block *sb, int xid)
250 FILE_UNIX_BASIC_INFO find_data;
251 struct cifsTconInfo *pTcon;
253 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
254 bool is_dfs_referral = false;
255 struct cifsInodeInfo *cifsInfo;
259 pTcon = cifs_sb->tcon;
260 cFYI(1, ("Getting info on %s", full_path));
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);
275 num_of_bytes = le64_to_cpu(find_data.NumOfBytes);
276 end_of_file = le64_to_cpu(find_data.EndOfFile);
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) {
289 cifsInfo = CIFS_I(inode);
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);
297 cifs_unix_info_to_inode(inode, &find_data, 0);
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));
305 cifs_set_ops(inode, is_dfs_referral);
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)
317 struct cifsTconInfo *pTcon = cifs_sb->tcon;
319 unsigned int bytes_read;
325 inode->i_mode |= S_IFIFO;
327 } else if (size < 8) {
328 return -EINVAL; /* EOPNOTSUPP? */
331 rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
332 CREATE_NOT_DIR, &netfid, &oplock, NULL,
334 cifs_sb->mnt_cifs_flags &
335 CIFS_MOUNT_MAP_SPECIAL_CHR);
337 int buf_type = CIFS_NO_BUFFER;
339 rc = CIFSSMBRead(xid, pTcon,
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);
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);
366 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
367 cFYI(1, ("Symlink"));
368 inode->i_mode |= S_IFLNK;
370 inode->i_mode |= S_IFREG; /* file? */
374 inode->i_mode |= S_IFREG; /* then it is a file */
375 rc = -EOPNOTSUPP; /* or some unknown SFU type */
377 CIFSSMBClose(xid, pTcon, netfid);
382 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
384 static int get_sfu_mode(struct inode *inode,
385 const unsigned char *path,
386 struct cifs_sb_info *cifs_sb, int xid)
388 #ifdef CONFIG_CIFS_XATTR
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);
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));
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)
418 static void fill_fake_finddata(FILE_ALL_INFO *pfnd_dat,
419 struct super_block *sb)
421 memset(pfnd_dat, 0, sizeof(FILE_ALL_INFO));
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);
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)
448 struct cifsInodeInfo *cifsInfo;
449 struct cifsTconInfo *pTcon;
451 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
453 bool adjustTZ = false;
454 bool is_dfs_referral = false;
455 umode_t default_mode;
457 pTcon = cifs_sb->tcon;
458 cFYI(1, ("Getting info on %s", full_path));
460 if ((pfindData == NULL) && (*pinode != NULL)) {
461 if (CIFS_I(*pinode)->clientCanCacheRead) {
462 cFYI(1, ("No need to revalidate cached inode sizes"));
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);
472 pfindData = (FILE_ALL_INFO *)buf;
474 /* could do find first instead but this returns more info */
475 rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
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);
490 /* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
491 if (rc == -EREMOTE) {
492 is_dfs_referral = true;
493 fill_fake_finddata(pfindData, sb);
498 attr = le32_to_cpu(pfindData->Attributes);
501 if (*pinode == NULL) {
503 __u64 *pinum = &inode_num;
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? */
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 */
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? */
519 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
522 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
525 cifs_sb->mnt_cifs_flags &
526 CIFS_MOUNT_MAP_SPECIAL_CHR);
528 cFYI(1, ("GetSrvInodeNum rc %d", rc1));
530 /* BB EOPNOSUPP disable SERVER_INUM? */
536 *pinode = cifs_new_inode(sb, pinum);
537 if (*pinode == NULL) {
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));
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;*/
555 /* Linux can not store file creation time so ignore it */
556 if (pfindData->LastAccessTime)
557 inode->i_atime = cifs_NTtimeToUnix(pfindData->LastAccessTime);
558 else /* do not need to use current_fs_time - time not stored */
559 inode->i_atime = CURRENT_TIME;
560 inode->i_mtime = cifs_NTtimeToUnix(pfindData->LastWriteTime);
561 inode->i_ctime = cifs_NTtimeToUnix(pfindData->ChangeTime);
562 cFYI(DBG2, ("Attributes came in as 0x%x", attr));
563 if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
564 inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
565 inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
568 /* get default inode mode */
569 if (attr & ATTR_DIRECTORY)
570 default_mode = cifs_sb->mnt_dir_mode;
572 default_mode = cifs_sb->mnt_file_mode;
574 /* set permission bits */
575 if (atomic_read(&cifsInfo->inUse) == 0 ||
576 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
577 inode->i_mode = default_mode;
579 /* just reenable write bits if !ATTR_READONLY */
580 if ((inode->i_mode & S_IWUGO) == 0 &&
581 (attr & ATTR_READONLY) == 0)
582 inode->i_mode |= (S_IWUGO & default_mode);
584 inode->i_mode &= ~S_IFMT;
586 /* clear write bits if ATTR_READONLY is set */
587 if (attr & ATTR_READONLY)
588 inode->i_mode &= ~S_IWUGO;
591 if ((attr & ATTR_SYSTEM) &&
592 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)) {
593 /* no need to fix endianness on 0 */
594 if (pfindData->EndOfFile == 0)
595 inode->i_mode |= S_IFIFO;
596 else if (decode_sfu_inode(inode,
597 le64_to_cpu(pfindData->EndOfFile),
598 full_path, cifs_sb, xid))
599 cFYI(1, ("unknown SFU file type\n"));
601 if (attr & ATTR_DIRECTORY)
602 inode->i_mode |= S_IFDIR;
604 inode->i_mode |= S_IFREG;
607 cifsInfo->server_eof = le64_to_cpu(pfindData->EndOfFile);
608 spin_lock(&inode->i_lock);
609 if (is_size_safe_to_change(cifsInfo, cifsInfo->server_eof)) {
610 /* can not safely shrink the file size here if the
611 client is writing to it due to potential races */
612 i_size_write(inode, cifsInfo->server_eof);
614 /* 512 bytes (2**9) is the fake blocksize that must be
615 used for this calculation */
616 inode->i_blocks = (512 - 1 + le64_to_cpu(
617 pfindData->AllocationSize)) >> 9;
619 spin_unlock(&inode->i_lock);
621 inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);
623 /* BB fill in uid and gid here? with help from winbind?
624 or retrieve from NTFS stream extended attribute */
625 #ifdef CONFIG_CIFS_EXPERIMENTAL
626 /* fill in 0777 bits from ACL */
627 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
628 cFYI(1, ("Getting mode bits from ACL"));
629 acl_to_uid_mode(cifs_sb, inode, full_path, pfid);
632 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
633 /* fill in remaining high mode bits e.g. SUID, VTX */
634 get_sfu_mode(inode, full_path, cifs_sb, xid);
635 } else if (atomic_read(&cifsInfo->inUse) == 0) {
636 inode->i_uid = cifs_sb->mnt_uid;
637 inode->i_gid = cifs_sb->mnt_gid;
638 /* set so we do not keep refreshing these fields with
639 bad data after user has changed them in memory */
640 atomic_set(&cifsInfo->inUse, 1);
643 cifs_set_ops(inode, is_dfs_referral);
653 static const struct inode_operations cifs_ipc_inode_ops = {
654 .lookup = cifs_lookup,
657 char *cifs_build_path_to_root(struct cifs_sb_info *cifs_sb)
659 int pplen = cifs_sb->prepathlen;
661 char *full_path = NULL;
663 /* if no prefix path, simply set path to the root of share to "" */
665 full_path = kmalloc(1, GFP_KERNEL);
671 if (cifs_sb->tcon && (cifs_sb->tcon->Flags & SMB_SHARE_IS_IN_DFS))
672 dfsplen = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE + 1);
676 full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
677 if (full_path == NULL)
681 strncpy(full_path, cifs_sb->tcon->treeName, dfsplen);
682 /* switch slash direction in prepath depending on whether
683 * windows or posix style path names
685 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
687 for (i = 0; i < dfsplen; i++) {
688 if (full_path[i] == '\\')
693 strncpy(full_path + dfsplen, cifs_sb->prepath, pplen);
694 full_path[dfsplen + pplen] = 0; /* add trailing null */
698 /* gets root inode */
699 struct inode *cifs_root_iget(struct super_block *sb, unsigned long ino)
702 struct cifs_sb_info *cifs_sb;
707 inode = iget_locked(sb, ino);
709 return ERR_PTR(-ENOMEM);
710 if (!(inode->i_state & I_NEW))
713 cifs_sb = CIFS_SB(inode->i_sb);
714 full_path = cifs_build_path_to_root(cifs_sb);
715 if (full_path == NULL)
716 return ERR_PTR(-ENOMEM);
719 if (cifs_sb->tcon->unix_ext)
720 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
723 rc = cifs_get_inode_info(&inode, full_path, NULL, inode->i_sb,
725 if (rc && cifs_sb->tcon->ipc) {
726 cFYI(1, ("ipc connection - fake read inode"));
727 inode->i_mode |= S_IFDIR;
729 inode->i_op = &cifs_ipc_inode_ops;
730 inode->i_fop = &simple_dir_operations;
731 inode->i_uid = cifs_sb->mnt_uid;
732 inode->i_gid = cifs_sb->mnt_gid;
740 unlock_new_inode(inode);
743 /* can not call macro FreeXid here since in a void func
744 * TODO: This is no longer true
751 cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
752 char *full_path, __u32 dosattr)
758 bool set_time = false;
759 struct cifsFileInfo *open_file;
760 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
761 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
762 struct cifsTconInfo *pTcon = cifs_sb->tcon;
763 FILE_BASIC_INFO info_buf;
768 if (attrs->ia_valid & ATTR_ATIME) {
770 info_buf.LastAccessTime =
771 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
773 info_buf.LastAccessTime = 0;
775 if (attrs->ia_valid & ATTR_MTIME) {
777 info_buf.LastWriteTime =
778 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
780 info_buf.LastWriteTime = 0;
783 * Samba throws this field away, but windows may actually use it.
784 * Do not set ctime unless other time stamps are changed explicitly
785 * (i.e. by utimes()) since we would then have a mix of client and
788 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
789 cFYI(1, ("CIFS - CTIME changed"));
790 info_buf.ChangeTime =
791 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
793 info_buf.ChangeTime = 0;
795 info_buf.CreationTime = 0; /* don't change */
796 info_buf.Attributes = cpu_to_le32(dosattr);
799 * If the file is already open for write, just use that fileid
801 open_file = find_writable_file(cifsInode);
803 netfid = open_file->netfid;
804 netpid = open_file->pid;
805 goto set_via_filehandle;
809 * NT4 apparently returns success on this call, but it doesn't
812 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
813 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
814 &info_buf, cifs_sb->local_nls,
815 cifs_sb->mnt_cifs_flags &
816 CIFS_MOUNT_MAP_SPECIAL_CHR);
818 cifsInode->cifsAttrs = dosattr;
820 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
824 cFYI(1, ("calling SetFileInfo since SetPathInfo for "
825 "times not supported by this server"));
826 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
827 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
828 CREATE_NOT_DIR, &netfid, &oplock,
829 NULL, cifs_sb->local_nls,
830 cifs_sb->mnt_cifs_flags &
831 CIFS_MOUNT_MAP_SPECIAL_CHR);
839 netpid = current->tgid;
842 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
844 cifsInode->cifsAttrs = dosattr;
846 if (open_file == NULL)
847 CIFSSMBClose(xid, pTcon, netfid);
849 atomic_dec(&open_file->wrtPending);
855 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
856 * and rename it to a random name that hopefully won't conflict with
860 cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
865 struct inode *inode = dentry->d_inode;
866 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
867 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
868 struct cifsTconInfo *tcon = cifs_sb->tcon;
869 __u32 dosattr, origattr;
870 FILE_BASIC_INFO *info_buf = NULL;
872 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
873 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
874 &netfid, &oplock, NULL, cifs_sb->local_nls,
875 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
879 origattr = cifsInode->cifsAttrs;
881 origattr |= ATTR_NORMAL;
883 dosattr = origattr & ~ATTR_READONLY;
885 dosattr |= ATTR_NORMAL;
886 dosattr |= ATTR_HIDDEN;
888 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
889 if (dosattr != origattr) {
890 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
891 if (info_buf == NULL) {
895 info_buf->Attributes = cpu_to_le32(dosattr);
896 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
898 /* although we would like to mark the file hidden
899 if that fails we will still try to rename it */
901 cifsInode->cifsAttrs = dosattr;
903 dosattr = origattr; /* since not able to change them */
906 /* rename the file */
907 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
908 cifs_sb->mnt_cifs_flags &
909 CIFS_MOUNT_MAP_SPECIAL_CHR);
915 /* try to set DELETE_ON_CLOSE */
916 if (!cifsInode->delete_pending) {
917 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
920 * some samba versions return -ENOENT when we try to set the
921 * file disposition here. Likely a samba bug, but work around
922 * it for now. This means that some cifsXXX files may hang
923 * around after they shouldn't.
925 * BB: remove this hack after more servers have the fix
933 cifsInode->delete_pending = true;
937 CIFSSMBClose(xid, tcon, netfid);
943 * reset everything back to the original state. Don't bother
944 * dealing with errors here since we can't do anything about
948 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
949 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
950 CIFS_MOUNT_MAP_SPECIAL_CHR);
952 if (dosattr != origattr) {
953 info_buf->Attributes = cpu_to_le32(origattr);
954 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
956 cifsInode->cifsAttrs = origattr;
964 * If dentry->d_inode is null (usually meaning the cached dentry
965 * is a negative dentry) then we would attempt a standard SMB delete, but
966 * if that fails we can not attempt the fall back mechanisms on EACESS
967 * but will return the EACESS to the caller. Note that the VFS does not call
968 * unlink on negative dentries currently.
970 int cifs_unlink(struct inode *dir, struct dentry *dentry)
974 char *full_path = NULL;
975 struct inode *inode = dentry->d_inode;
976 struct cifsInodeInfo *cifs_inode;
977 struct super_block *sb = dir->i_sb;
978 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
979 struct cifsTconInfo *tcon = cifs_sb->tcon;
980 struct iattr *attrs = NULL;
981 __u32 dosattr = 0, origattr = 0;
983 cFYI(1, ("cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry));
987 /* Unlink can be called from rename so we can not take the
988 * sb->s_vfs_rename_mutex here */
989 full_path = build_path_from_dentry(dentry);
990 if (full_path == NULL) {
996 if ((tcon->ses->capabilities & CAP_UNIX) &&
997 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
998 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
999 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1000 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1001 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1002 cFYI(1, ("posix del rc %d", rc));
1003 if ((rc == 0) || (rc == -ENOENT))
1004 goto psx_del_no_retry;
1008 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
1009 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1015 } else if (rc == -ENOENT) {
1017 } else if (rc == -ETXTBSY) {
1018 rc = cifs_rename_pending_delete(full_path, dentry, xid);
1021 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1022 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1023 if (attrs == NULL) {
1028 /* try to reset dos attributes */
1029 cifs_inode = CIFS_I(inode);
1030 origattr = cifs_inode->cifsAttrs;
1032 origattr |= ATTR_NORMAL;
1033 dosattr = origattr & ~ATTR_READONLY;
1035 dosattr |= ATTR_NORMAL;
1036 dosattr |= ATTR_HIDDEN;
1038 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1042 goto retry_std_delete;
1045 /* undo the setattr if we errored out and it's needed */
1046 if (rc != 0 && dosattr != 0)
1047 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1051 cifs_inode = CIFS_I(inode);
1052 cifs_inode->time = 0; /* will force revalidate to get info
1054 inode->i_ctime = current_fs_time(sb);
1056 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1057 cifs_inode = CIFS_I(dir);
1058 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1066 void posix_fill_in_inode(struct inode *tmp_inode,
1067 FILE_UNIX_BASIC_INFO *pData, int isNewInode)
1069 struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
1071 struct timespec local_mtime;
1073 cifsInfo->time = jiffies;
1074 atomic_inc(&cifsInfo->inUse);
1076 /* save mtime and size */
1077 local_mtime = tmp_inode->i_mtime;
1078 local_size = tmp_inode->i_size;
1080 cifs_unix_info_to_inode(tmp_inode, pData, 1);
1081 cifs_set_ops(tmp_inode, false);
1083 if (!S_ISREG(tmp_inode->i_mode))
1087 * No sense invalidating pages for new inode
1088 * since we we have not started caching
1089 * readahead file data yet.
1094 if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
1095 (local_size == tmp_inode->i_size)) {
1096 cFYI(1, ("inode exists but unchanged"));
1098 /* file may have changed on server */
1099 cFYI(1, ("invalidate inode, readdir detected change"));
1100 invalidate_remote_inode(tmp_inode);
1104 int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1108 struct cifs_sb_info *cifs_sb;
1109 struct cifsTconInfo *pTcon;
1110 char *full_path = NULL;
1111 struct inode *newinode = NULL;
1113 cFYI(1, ("In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode));
1117 cifs_sb = CIFS_SB(inode->i_sb);
1118 pTcon = cifs_sb->tcon;
1120 full_path = build_path_from_dentry(direntry);
1121 if (full_path == NULL) {
1127 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1128 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1129 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1131 FILE_UNIX_BASIC_INFO *pInfo =
1132 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1133 if (pInfo == NULL) {
1138 mode &= ~current_umask();
1139 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1140 mode, NULL /* netfid */, pInfo, &oplock,
1141 full_path, cifs_sb->local_nls,
1142 cifs_sb->mnt_cifs_flags &
1143 CIFS_MOUNT_MAP_SPECIAL_CHR);
1144 if (rc == -EOPNOTSUPP) {
1146 goto mkdir_retry_old;
1148 cFYI(1, ("posix mkdir returned 0x%x", rc));
1152 if (pInfo->Type == cpu_to_le32(-1)) {
1153 /* no return info, go query for it */
1155 goto mkdir_get_info;
1157 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1161 direntry->d_op = &cifs_ci_dentry_ops;
1163 direntry->d_op = &cifs_dentry_ops;
1165 unique_id = le64_to_cpu(pInfo->UniqueId);
1166 newinode = cifs_new_inode(inode->i_sb, &unique_id);
1167 if (newinode == NULL) {
1169 goto mkdir_get_info;
1172 newinode->i_nlink = 2;
1173 d_instantiate(direntry, newinode);
1175 /* we already checked in POSIXCreate whether
1176 frame was long enough */
1177 posix_fill_in_inode(direntry->d_inode,
1178 pInfo, 1 /* NewInode */);
1179 #ifdef CONFIG_CIFS_DEBUG2
1180 cFYI(1, ("instantiated dentry %p %s to inode %p",
1181 direntry, direntry->d_name.name, newinode));
1183 if (newinode->i_nlink != 2)
1184 cFYI(1, ("unexpected number of links %d",
1185 newinode->i_nlink));
1192 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1193 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1194 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1196 cFYI(1, ("cifs_mkdir returned 0x%x", rc));
1201 if (pTcon->unix_ext)
1202 rc = cifs_get_inode_info_unix(&newinode, full_path,
1205 rc = cifs_get_inode_info(&newinode, full_path, NULL,
1206 inode->i_sb, xid, NULL);
1209 direntry->d_op = &cifs_ci_dentry_ops;
1211 direntry->d_op = &cifs_dentry_ops;
1212 d_instantiate(direntry, newinode);
1213 /* setting nlink not necessary except in cases where we
1214 * failed to get it from the server or was set bogus */
1215 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
1216 direntry->d_inode->i_nlink = 2;
1218 mode &= ~current_umask();
1219 /* must turn on setgid bit if parent dir has it */
1220 if (inode->i_mode & S_ISGID)
1223 if (pTcon->unix_ext) {
1224 struct cifs_unix_set_info_args args = {
1226 .ctime = NO_CHANGE_64,
1227 .atime = NO_CHANGE_64,
1228 .mtime = NO_CHANGE_64,
1231 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1232 args.uid = (__u64)current_fsuid();
1233 if (inode->i_mode & S_ISGID)
1234 args.gid = (__u64)inode->i_gid;
1236 args.gid = (__u64)current_fsgid();
1238 args.uid = NO_CHANGE_64;
1239 args.gid = NO_CHANGE_64;
1241 CIFSSMBUnixSetInfo(xid, pTcon, full_path, &args,
1243 cifs_sb->mnt_cifs_flags &
1244 CIFS_MOUNT_MAP_SPECIAL_CHR);
1246 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1247 (mode & S_IWUGO) == 0) {
1248 FILE_BASIC_INFO pInfo;
1249 struct cifsInodeInfo *cifsInode;
1252 memset(&pInfo, 0, sizeof(pInfo));
1253 cifsInode = CIFS_I(newinode);
1254 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1255 pInfo.Attributes = cpu_to_le32(dosattrs);
1256 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1259 cifs_sb->mnt_cifs_flags &
1260 CIFS_MOUNT_MAP_SPECIAL_CHR);
1262 cifsInode->cifsAttrs = dosattrs;
1264 if (direntry->d_inode) {
1265 if (cifs_sb->mnt_cifs_flags &
1267 direntry->d_inode->i_mode =
1270 if (cifs_sb->mnt_cifs_flags &
1271 CIFS_MOUNT_SET_UID) {
1272 direntry->d_inode->i_uid =
1274 if (inode->i_mode & S_ISGID)
1275 direntry->d_inode->i_gid =
1278 direntry->d_inode->i_gid =
1290 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1294 struct cifs_sb_info *cifs_sb;
1295 struct cifsTconInfo *pTcon;
1296 char *full_path = NULL;
1297 struct cifsInodeInfo *cifsInode;
1299 cFYI(1, ("cifs_rmdir, inode = 0x%p", inode));
1303 cifs_sb = CIFS_SB(inode->i_sb);
1304 pTcon = cifs_sb->tcon;
1306 full_path = build_path_from_dentry(direntry);
1307 if (full_path == NULL) {
1313 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1314 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
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);
1324 cifsInode = CIFS_I(direntry->d_inode);
1325 cifsInode->time = 0; /* force revalidate to go get info when
1328 cifsInode = CIFS_I(inode);
1329 cifsInode->time = 0; /* force revalidate to get parent dir info
1330 since cached search results now invalid */
1332 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1333 current_fs_time(inode->i_sb);
1341 cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1342 struct dentry *to_dentry, const char *toPath)
1344 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1345 struct cifsTconInfo *pTcon = cifs_sb->tcon;
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);
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.
1359 if (rc == 0 || rc != -ETXTBSY)
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);
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);
1374 CIFSSMBClose(xid, pTcon, srcfid);
1380 int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1381 struct inode *target_dir, struct dentry *target_dentry)
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;
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;
1399 * BB: this might be allowed if same server, but different share.
1400 * Consider adding support for this
1402 if (tcon != cifs_sb_target->tcon) {
1404 goto cifs_rename_exit;
1408 * we already have the rename sem so we do not need to
1409 * grab it again here to protect the path integrity
1411 fromName = build_path_from_dentry(source_dentry);
1412 if (fromName == NULL) {
1414 goto cifs_rename_exit;
1417 toName = build_path_from_dentry(target_dentry);
1418 if (toName == NULL) {
1420 goto cifs_rename_exit;
1423 rc = cifs_do_rename(xid, source_dentry, fromName,
1424 target_dentry, toName);
1426 if (rc == -EEXIST && tcon->unix_ext) {
1428 * Are src and dst hardlinks of same inode? We can
1429 * only tell with unix extensions enabled
1432 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1434 if (info_buf_source == NULL) {
1436 goto cifs_rename_exit;
1439 info_buf_target = info_buf_source + 1;
1440 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
1442 cifs_sb_source->local_nls,
1443 cifs_sb_source->mnt_cifs_flags &
1444 CIFS_MOUNT_MAP_SPECIAL_CHR);
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);
1455 if (tmprc == 0 && (info_buf_source->UniqueId ==
1456 info_buf_target->UniqueId)) {
1457 /* same file, POSIX says that this is a noop */
1459 goto cifs_rename_exit;
1461 } /* else ... BB we could add the same check for Windows by
1462 checking the UniqueId via FILE_INTERNAL_INFO */
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);
1469 goto cifs_rename_exit;
1471 rc = cifs_do_rename(xid, source_dentry, fromName,
1472 target_dentry, toName);
1476 kfree(info_buf_source);
1483 int cifs_revalidate(struct dentry *direntry)
1486 int rc = 0, wbrc = 0;
1488 struct cifs_sb_info *cifs_sb;
1489 struct cifsInodeInfo *cifsInode;
1491 struct timespec local_mtime;
1492 bool invalidate_inode = false;
1494 if (direntry->d_inode == NULL)
1497 cifsInode = CIFS_I(direntry->d_inode);
1499 if (cifsInode == NULL)
1502 /* no sense revalidating inode info on file that no one can write */
1503 if (CIFS_I(direntry->d_inode)->clientCanCacheRead)
1508 cifs_sb = CIFS_SB(direntry->d_sb);
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) {
1518 cFYI(1, ("Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1519 "jiffies %ld", full_path, direntry->d_inode,
1520 direntry->d_inode->i_count.counter, direntry,
1521 direntry->d_time, jiffies));
1523 if (cifsInode->time == 0) {
1524 /* was set to zero previously to force revalidate */
1525 } else if (time_before(jiffies, cifsInode->time + HZ) &&
1526 lookupCacheEnabled) {
1527 if ((S_ISREG(direntry->d_inode->i_mode) == 0) ||
1528 (direntry->d_inode->i_nlink == 1)) {
1533 cFYI(1, ("Have to revalidate file due to hardlinks"));
1537 /* save mtime and size */
1538 local_mtime = direntry->d_inode->i_mtime;
1539 local_size = direntry->d_inode->i_size;
1541 if (cifs_sb->tcon->unix_ext) {
1542 rc = cifs_get_inode_info_unix(&direntry->d_inode, full_path,
1543 direntry->d_sb, xid);
1545 cFYI(1, ("error on getting revalidate info %d", rc));
1546 /* if (rc != -ENOENT)
1547 rc = 0; */ /* BB should we cache info on
1551 rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
1552 direntry->d_sb, xid, NULL);
1554 cFYI(1, ("error on getting revalidate info %d", rc));
1555 /* if (rc != -ENOENT)
1556 rc = 0; */ /* BB should we cache info on
1560 /* should we remap certain errors, access denied?, to zero */
1562 /* if not oplocked, we invalidate inode pages if mtime or file size
1563 had changed on server */
1565 if (timespec_equal(&local_mtime, &direntry->d_inode->i_mtime) &&
1566 (local_size == direntry->d_inode->i_size)) {
1567 cFYI(1, ("cifs_revalidate - inode unchanged"));
1569 /* file may have changed on server */
1570 if (cifsInode->clientCanCacheRead) {
1571 /* no need to invalidate inode pages since we were the
1572 only ones who could have modified the file and the
1573 server copy is staler than ours */
1575 invalidate_inode = true;
1579 /* can not grab this sem since kernel filesys locking documentation
1580 indicates i_mutex may be taken by the kernel on lookup and rename
1581 which could deadlock if we grab the i_mutex here as well */
1582 /* mutex_lock(&direntry->d_inode->i_mutex);*/
1583 /* need to write out dirty pages here */
1584 if (direntry->d_inode->i_mapping) {
1585 /* do we need to lock inode until after invalidate completes
1587 wbrc = filemap_fdatawrite(direntry->d_inode->i_mapping);
1589 CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
1591 if (invalidate_inode) {
1592 /* shrink_dcache not necessary now that cifs dentry ops
1593 are exported for negative dentries */
1594 /* if (S_ISDIR(direntry->d_inode->i_mode))
1595 shrink_dcache_parent(direntry); */
1596 if (S_ISREG(direntry->d_inode->i_mode)) {
1597 if (direntry->d_inode->i_mapping) {
1598 wbrc = filemap_fdatawait(direntry->d_inode->i_mapping);
1600 CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
1602 /* may eventually have to do this for open files too */
1603 if (list_empty(&(cifsInode->openFileList))) {
1604 /* changed on server - flush read ahead pages */
1605 cFYI(1, ("Invalidating read ahead data on "
1607 invalidate_remote_inode(direntry->d_inode);
1611 /* mutex_unlock(&direntry->d_inode->i_mutex); */
1618 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1621 int err = cifs_revalidate(dentry);
1623 generic_fillattr(dentry->d_inode, stat);
1624 stat->blksize = CIFS_MAX_MSGSIZE;
1629 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1631 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1632 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1636 page = grab_cache_page(mapping, index);
1640 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1642 page_cache_release(page);
1646 static int cifs_vmtruncate(struct inode *inode, loff_t offset)
1648 struct address_space *mapping = inode->i_mapping;
1649 unsigned long limit;
1651 spin_lock(&inode->i_lock);
1652 if (inode->i_size < offset)
1655 * truncation of in-use swapfiles is disallowed - it would cause
1656 * subsequent swapout to scribble on the now-freed blocks.
1658 if (IS_SWAPFILE(inode)) {
1659 spin_unlock(&inode->i_lock);
1662 i_size_write(inode, offset);
1663 spin_unlock(&inode->i_lock);
1665 * unmap_mapping_range is called twice, first simply for efficiency
1666 * so that truncate_inode_pages does fewer single-page unmaps. However
1667 * after this first call, and before truncate_inode_pages finishes,
1668 * it is possible for private pages to be COWed, which remain after
1669 * truncate_inode_pages finishes, hence the second unmap_mapping_range
1670 * call must be made for correctness.
1672 unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
1673 truncate_inode_pages(mapping, offset);
1674 unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
1678 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
1679 if (limit != RLIM_INFINITY && offset > limit) {
1680 spin_unlock(&inode->i_lock);
1683 if (offset > inode->i_sb->s_maxbytes) {
1684 spin_unlock(&inode->i_lock);
1687 i_size_write(inode, offset);
1688 spin_unlock(&inode->i_lock);
1690 if (inode->i_op->truncate)
1691 inode->i_op->truncate(inode);
1694 send_sig(SIGXFSZ, current, 0);
1702 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1703 int xid, char *full_path)
1706 struct cifsFileInfo *open_file;
1707 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1708 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1709 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1712 * To avoid spurious oplock breaks from server, in the case of
1713 * inodes that we already have open, avoid doing path based
1714 * setting of file size if we can do it by handle.
1715 * This keeps our caching token (oplock) and avoids timeouts
1716 * when the local oplock break takes longer to flush
1717 * writebehind data than the SMB timeout for the SetPathInfo
1718 * request would allow
1720 open_file = find_writable_file(cifsInode);
1722 __u16 nfid = open_file->netfid;
1723 __u32 npid = open_file->pid;
1724 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1726 atomic_dec(&open_file->wrtPending);
1727 cFYI(1, ("SetFSize for attrs rc = %d", rc));
1728 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1729 unsigned int bytes_written;
1730 rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
1731 &bytes_written, NULL, NULL, 1);
1732 cFYI(1, ("Wrt seteof rc %d", rc));
1738 /* Set file size by pathname rather than by handle
1739 either because no valid, writeable file handle for
1740 it was found or because there was an error setting
1742 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1743 false, cifs_sb->local_nls,
1744 cifs_sb->mnt_cifs_flags &
1745 CIFS_MOUNT_MAP_SPECIAL_CHR);
1746 cFYI(1, ("SetEOF by path (setattrs) rc = %d", rc));
1747 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1751 rc = SMBLegacyOpen(xid, pTcon, full_path,
1752 FILE_OPEN, GENERIC_WRITE,
1753 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1755 cifs_sb->mnt_cifs_flags &
1756 CIFS_MOUNT_MAP_SPECIAL_CHR);
1758 unsigned int bytes_written;
1759 rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
1761 &bytes_written, NULL,
1763 cFYI(1, ("wrt seteof rc %d", rc));
1764 CIFSSMBClose(xid, pTcon, netfid);
1770 cifsInode->server_eof = attrs->ia_size;
1771 rc = cifs_vmtruncate(inode, attrs->ia_size);
1772 cifs_truncate_page(inode->i_mapping, inode->i_size);
1779 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1783 char *full_path = NULL;
1784 struct inode *inode = direntry->d_inode;
1785 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1786 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1787 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1788 struct cifs_unix_set_info_args *args = NULL;
1790 cFYI(1, ("setattr_unix on file %s attrs->ia_valid=0x%x",
1791 direntry->d_name.name, attrs->ia_valid));
1795 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1796 /* check if we have permission to change attrs */
1797 rc = inode_change_ok(inode, attrs);
1804 full_path = build_path_from_dentry(direntry);
1805 if (full_path == NULL) {
1811 * Attempt to flush data before changing attributes. We need to do
1812 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1813 * ownership or mode then we may also need to do this. Here, we take
1814 * the safe way out and just do the flush on all setattr requests. If
1815 * the flush returns error, store it to report later and continue.
1817 * BB: This should be smarter. Why bother flushing pages that
1818 * will be truncated anyway? Also, should we error out here if
1819 * the flush returns error?
1821 rc = filemap_write_and_wait(inode->i_mapping);
1823 cifsInode->write_behind_rc = rc;
1827 if (attrs->ia_valid & ATTR_SIZE) {
1828 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1833 /* skip mode change if it's just for clearing setuid/setgid */
1834 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1835 attrs->ia_valid &= ~ATTR_MODE;
1837 args = kmalloc(sizeof(*args), GFP_KERNEL);
1843 /* set up the struct */
1844 if (attrs->ia_valid & ATTR_MODE)
1845 args->mode = attrs->ia_mode;
1847 args->mode = NO_CHANGE_64;
1849 if (attrs->ia_valid & ATTR_UID)
1850 args->uid = attrs->ia_uid;
1852 args->uid = NO_CHANGE_64;
1854 if (attrs->ia_valid & ATTR_GID)
1855 args->gid = attrs->ia_gid;
1857 args->gid = NO_CHANGE_64;
1859 if (attrs->ia_valid & ATTR_ATIME)
1860 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
1862 args->atime = NO_CHANGE_64;
1864 if (attrs->ia_valid & ATTR_MTIME)
1865 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
1867 args->mtime = NO_CHANGE_64;
1869 if (attrs->ia_valid & ATTR_CTIME)
1870 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
1872 args->ctime = NO_CHANGE_64;
1875 rc = CIFSSMBUnixSetInfo(xid, pTcon, full_path, args,
1877 cifs_sb->mnt_cifs_flags &
1878 CIFS_MOUNT_MAP_SPECIAL_CHR);
1881 rc = inode_setattr(inode, attrs);
1890 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
1893 struct inode *inode = direntry->d_inode;
1894 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1895 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1896 char *full_path = NULL;
1899 __u64 mode = NO_CHANGE_64;
1903 cFYI(1, ("setattr on file %s attrs->iavalid 0x%x",
1904 direntry->d_name.name, attrs->ia_valid));
1906 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1907 /* check if we have permission to change attrs */
1908 rc = inode_change_ok(inode, attrs);
1916 full_path = build_path_from_dentry(direntry);
1917 if (full_path == NULL) {
1924 * Attempt to flush data before changing attributes. We need to do
1925 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1926 * ownership or mode then we may also need to do this. Here, we take
1927 * the safe way out and just do the flush on all setattr requests. If
1928 * the flush returns error, store it to report later and continue.
1930 * BB: This should be smarter. Why bother flushing pages that
1931 * will be truncated anyway? Also, should we error out here if
1932 * the flush returns error?
1934 rc = filemap_write_and_wait(inode->i_mapping);
1936 cifsInode->write_behind_rc = rc;
1940 if (attrs->ia_valid & ATTR_SIZE) {
1941 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1943 goto cifs_setattr_exit;
1947 * Without unix extensions we can't send ownership changes to the
1948 * server, so silently ignore them. This is consistent with how
1949 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
1950 * CIFSACL support + proper Windows to Unix idmapping, we may be
1951 * able to support this in the future.
1953 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
1954 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
1956 /* skip mode change if it's just for clearing setuid/setgid */
1957 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1958 attrs->ia_valid &= ~ATTR_MODE;
1960 if (attrs->ia_valid & ATTR_MODE) {
1961 cFYI(1, ("Mode changed to 0%o", attrs->ia_mode));
1962 mode = attrs->ia_mode;
1965 if (attrs->ia_valid & ATTR_MODE) {
1967 #ifdef CONFIG_CIFS_EXPERIMENTAL
1968 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
1969 rc = mode_to_acl(inode, full_path, mode);
1972 if (((mode & S_IWUGO) == 0) &&
1973 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
1975 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
1977 /* fix up mode if we're not using dynperm */
1978 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
1979 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
1980 } else if ((mode & S_IWUGO) &&
1981 (cifsInode->cifsAttrs & ATTR_READONLY)) {
1983 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
1984 /* Attributes of 0 are ignored */
1986 dosattr |= ATTR_NORMAL;
1988 /* reset local inode permissions to normal */
1989 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
1990 attrs->ia_mode &= ~(S_IALLUGO);
1991 if (S_ISDIR(inode->i_mode))
1993 cifs_sb->mnt_dir_mode;
1996 cifs_sb->mnt_file_mode;
1998 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
1999 /* ignore mode change - ATTR_READONLY hasn't changed */
2000 attrs->ia_valid &= ~ATTR_MODE;
2004 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2005 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2006 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2007 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2009 /* Even if error on time set, no sense failing the call if
2010 the server would set the time to a reasonable value anyway,
2011 and this check ensures that we are not being called from
2012 sys_utimes in which case we ought to fail the call back to
2013 the user when the server rejects the call */
2014 if ((rc) && (attrs->ia_valid &
2015 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2019 /* do not need local check to inode_check_ok since the server does
2022 rc = inode_setattr(inode, attrs);
2030 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2032 struct inode *inode = direntry->d_inode;
2033 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2034 struct cifsTconInfo *pTcon = cifs_sb->tcon;
2036 if (pTcon->unix_ext)
2037 return cifs_setattr_unix(direntry, attrs);
2039 return cifs_setattr_nounix(direntry, attrs);
2041 /* BB: add cifs_setattr_legacy for really old servers */
2045 void cifs_delete_inode(struct inode *inode)
2047 cFYI(1, ("In cifs_delete_inode, inode = 0x%p", inode));
2048 /* may have to add back in if and when safe distributed caching of
2049 directories added e.g. via FindNotify */