4 * Copyright (C) International Business Machines Corp., 2002,2007
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)
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 inode->i_op = &cifs_dir_inode_ops;
61 inode->i_fop = &cifs_dir_ops;
64 inode->i_op = &cifs_symlink_inode_ops;
67 init_special_inode(inode, inode->i_mode, inode->i_rdev);
72 int cifs_get_inode_info_unix(struct inode **pinode,
73 const unsigned char *search_path, struct super_block *sb, int xid)
76 FILE_UNIX_BASIC_INFO findData;
77 struct cifsTconInfo *pTcon;
79 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
82 pTcon = cifs_sb->tcon;
83 cFYI(1, ("Getting info on %s", search_path));
84 /* could have done a find first instead but this returns more info */
85 rc = CIFSSMBUnixQPathInfo(xid, pTcon, search_path, &findData,
86 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
87 CIFS_MOUNT_MAP_SPECIAL_CHR);
88 /* dump_mem("\nUnixQPathInfo return data", &findData,
93 kmalloc(strnlen(pTcon->treeName,
95 strnlen(search_path, MAX_PATHCONF) + 1,
100 /* have to skip first of the double backslash of
102 strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
103 strncat(tmp_path, search_path, MAX_PATHCONF);
104 rc = connect_to_dfs_path(xid, pTcon->ses,
105 /* treename + */ tmp_path,
107 cifs_sb->mnt_cifs_flags &
108 CIFS_MOUNT_MAP_SPECIAL_CHR);
111 /* BB fix up inode etc. */
116 struct cifsInodeInfo *cifsInfo;
117 __u32 type = le32_to_cpu(findData.Type);
118 __u64 num_of_bytes = le64_to_cpu(findData.NumOfBytes);
119 __u64 end_of_file = le64_to_cpu(findData.EndOfFile);
122 if (*pinode == NULL) {
123 *pinode = new_inode(sb);
126 /* Is an i_ino of zero legal? */
127 /* Are there sanity checks we can use to ensure that
128 the server is really filling in that field? */
129 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
131 (unsigned long)findData.UniqueId;
132 } /* note ino incremented to unique num in new_inode */
133 if (sb->s_flags & MS_NOATIME)
134 (*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
136 insert_inode_hash(*pinode);
140 cifsInfo = CIFS_I(inode);
142 cFYI(1, ("Old time %ld", cifsInfo->time));
143 cifsInfo->time = jiffies;
144 cFYI(1, ("New time %ld", cifsInfo->time));
145 /* this is ok to set on every inode revalidate */
146 atomic_set(&cifsInfo->inUse, 1);
149 cifs_NTtimeToUnix(le64_to_cpu(findData.LastAccessTime));
151 cifs_NTtimeToUnix(le64_to_cpu
152 (findData.LastModificationTime));
154 cifs_NTtimeToUnix(le64_to_cpu(findData.LastStatusChange));
155 inode->i_mode = le64_to_cpu(findData.Permissions);
156 /* since we set the inode type below we need to mask off
157 to avoid strange results if bits set above */
158 inode->i_mode &= ~S_IFMT;
159 if (type == UNIX_FILE) {
160 inode->i_mode |= S_IFREG;
161 } else if (type == UNIX_SYMLINK) {
162 inode->i_mode |= S_IFLNK;
163 } else if (type == UNIX_DIR) {
164 inode->i_mode |= S_IFDIR;
165 } else if (type == UNIX_CHARDEV) {
166 inode->i_mode |= S_IFCHR;
167 inode->i_rdev = MKDEV(le64_to_cpu(findData.DevMajor),
168 le64_to_cpu(findData.DevMinor) & MINORMASK);
169 } else if (type == UNIX_BLOCKDEV) {
170 inode->i_mode |= S_IFBLK;
171 inode->i_rdev = MKDEV(le64_to_cpu(findData.DevMajor),
172 le64_to_cpu(findData.DevMinor) & MINORMASK);
173 } else if (type == UNIX_FIFO) {
174 inode->i_mode |= S_IFIFO;
175 } else if (type == UNIX_SOCKET) {
176 inode->i_mode |= S_IFSOCK;
178 /* safest to call it a file if we do not know */
179 inode->i_mode |= S_IFREG;
180 cFYI(1, ("unknown type %d", type));
183 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
184 inode->i_uid = cifs_sb->mnt_uid;
186 inode->i_uid = le64_to_cpu(findData.Uid);
188 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
189 inode->i_gid = cifs_sb->mnt_gid;
191 inode->i_gid = le64_to_cpu(findData.Gid);
193 inode->i_nlink = le64_to_cpu(findData.Nlinks);
195 spin_lock(&inode->i_lock);
196 if (is_size_safe_to_change(cifsInfo, end_of_file)) {
197 /* can not safely change the file size here if the
198 client is writing to it due to potential races */
199 i_size_write(inode, end_of_file);
201 /* blksize needs to be multiple of two. So safer to default to
202 blksize and blkbits set in superblock so 2**blkbits and blksize
203 will match rather than setting to:
204 (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
206 /* This seems incredibly stupid but it turns out that i_blocks
207 is not related to (i_size / i_blksize), instead 512 byte size
208 is required for calculating num blocks */
210 /* 512 bytes (2**9) is the fake blocksize that must be used */
211 /* for this calculation */
212 inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
214 spin_unlock(&inode->i_lock);
216 if (num_of_bytes < end_of_file)
217 cFYI(1, ("allocation size less than end of file"));
218 cFYI(1, ("Size %ld and blocks %llu",
219 (unsigned long) inode->i_size,
220 (unsigned long long)inode->i_blocks));
227 static int decode_sfu_inode(struct inode *inode, __u64 size,
228 const unsigned char *path,
229 struct cifs_sb_info *cifs_sb, int xid)
234 struct cifsTconInfo *pTcon = cifs_sb->tcon;
236 unsigned int bytes_read;
242 inode->i_mode |= S_IFIFO;
244 } else if (size < 8) {
245 return -EINVAL; /* EOPNOTSUPP? */
248 rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
249 CREATE_NOT_DIR, &netfid, &oplock, NULL,
251 cifs_sb->mnt_cifs_flags &
252 CIFS_MOUNT_MAP_SPECIAL_CHR);
254 int buf_type = CIFS_NO_BUFFER;
256 rc = CIFSSMBRead(xid, pTcon,
258 24 /* length */, 0 /* offset */,
259 &bytes_read, &pbuf, &buf_type);
260 if ((rc == 0) && (bytes_read >= 8)) {
261 if (memcmp("IntxBLK", pbuf, 8) == 0) {
262 cFYI(1, ("Block device"));
263 inode->i_mode |= S_IFBLK;
264 if (bytes_read == 24) {
265 /* we have enough to decode dev num */
266 __u64 mjr; /* major */
267 __u64 mnr; /* minor */
268 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
269 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
270 inode->i_rdev = MKDEV(mjr, mnr);
272 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
273 cFYI(1, ("Char device"));
274 inode->i_mode |= S_IFCHR;
275 if (bytes_read == 24) {
276 /* we have enough to decode dev num */
277 __u64 mjr; /* major */
278 __u64 mnr; /* minor */
279 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
280 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
281 inode->i_rdev = MKDEV(mjr, mnr);
283 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
284 cFYI(1, ("Symlink"));
285 inode->i_mode |= S_IFLNK;
287 inode->i_mode |= S_IFREG; /* file? */
291 inode->i_mode |= S_IFREG; /* then it is a file */
292 rc = -EOPNOTSUPP; /* or some unknown SFU type */
294 CIFSSMBClose(xid, pTcon, netfid);
299 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
301 static int get_sfu_mode(struct inode *inode,
302 const unsigned char *path,
303 struct cifs_sb_info *cifs_sb, int xid)
305 #ifdef CONFIG_CIFS_XATTR
310 rc = CIFSSMBQueryEA(xid, cifs_sb->tcon, path, "SETFILEBITS",
311 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
312 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
316 mode = le32_to_cpu(*((__le32 *)ea_value));
317 inode->i_mode &= ~SFBITS_MASK;
318 cFYI(1, ("special bits 0%o org mode 0%o", mode, inode->i_mode));
319 inode->i_mode = (mode & SFBITS_MASK) | inode->i_mode;
320 cFYI(1, ("special mode bits 0%o", mode));
330 int cifs_get_inode_info(struct inode **pinode,
331 const unsigned char *search_path, FILE_ALL_INFO *pfindData,
332 struct super_block *sb, int xid)
335 struct cifsTconInfo *pTcon;
337 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
340 int adjustTZ = FALSE;
342 pTcon = cifs_sb->tcon;
343 cFYI(1, ("Getting info on %s", search_path));
345 if ((pfindData == NULL) && (*pinode != NULL)) {
346 if (CIFS_I(*pinode)->clientCanCacheRead) {
347 cFYI(1, ("No need to revalidate cached inode sizes"));
352 /* if file info not passed in then get it from server */
353 if (pfindData == NULL) {
354 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
357 pfindData = (FILE_ALL_INFO *)buf;
358 /* could do find first instead but this returns more info */
359 rc = CIFSSMBQPathInfo(xid, pTcon, search_path, pfindData,
361 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
362 CIFS_MOUNT_MAP_SPECIAL_CHR);
363 /* BB optimize code so we do not make the above call
364 when server claims no NT SMB support and the above call
365 failed at least once - set flag in tcon or mount */
366 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
367 rc = SMBQueryInformation(xid, pTcon, search_path,
368 pfindData, cifs_sb->local_nls,
369 cifs_sb->mnt_cifs_flags &
370 CIFS_MOUNT_MAP_SPECIAL_CHR);
374 /* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
376 if (rc == -EREMOTE) {
381 strnlen(search_path, MAX_PATHCONF) + 1,
383 if (tmp_path == NULL) {
388 strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
389 strncat(tmp_path, search_path, MAX_PATHCONF);
390 rc = connect_to_dfs_path(xid, pTcon->ses,
391 /* treename + */ tmp_path,
393 cifs_sb->mnt_cifs_flags &
394 CIFS_MOUNT_MAP_SPECIAL_CHR);
396 /* BB fix up inode etc. */
402 struct cifsInodeInfo *cifsInfo;
403 __u32 attr = le32_to_cpu(pfindData->Attributes);
406 if (*pinode == NULL) {
407 *pinode = new_inode(sb);
408 if (*pinode == NULL) {
412 /* Is an i_ino of zero legal? Can we use that to check
413 if the server supports returning inode numbers? Are
414 there other sanity checks we can use to ensure that
415 the server is really filling in that field? */
417 /* We can not use the IndexNumber field by default from
418 Windows or Samba (in ALL_INFO buf) but we can request
419 it explicitly. It may not be unique presumably if
420 the server has multiple devices mounted under one
423 /* There may be higher info levels that work but are
424 there Windows server or network appliances for which
425 IndexNumber field is not guaranteed unique? */
427 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
431 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
432 search_path, &inode_num,
434 cifs_sb->mnt_cifs_flags &
435 CIFS_MOUNT_MAP_SPECIAL_CHR);
437 cFYI(1, ("GetSrvInodeNum rc %d", rc1));
438 /* BB EOPNOSUPP disable SERVER_INUM? */
439 } else /* do we need cast or hash to ino? */
440 (*pinode)->i_ino = inode_num;
441 } /* else ino incremented to unique num in new_inode*/
442 if (sb->s_flags & MS_NOATIME)
443 (*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
444 insert_inode_hash(*pinode);
447 cifsInfo = CIFS_I(inode);
448 cifsInfo->cifsAttrs = attr;
449 cFYI(1, ("Old time %ld", cifsInfo->time));
450 cifsInfo->time = jiffies;
451 cFYI(1, ("New time %ld", cifsInfo->time));
453 /* blksize needs to be multiple of two. So safer to default to
454 blksize and blkbits set in superblock so 2**blkbits and blksize
455 will match rather than setting to:
456 (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
458 /* Linux can not store file creation time so ignore it */
459 if (pfindData->LastAccessTime)
460 inode->i_atime = cifs_NTtimeToUnix
461 (le64_to_cpu(pfindData->LastAccessTime));
462 else /* do not need to use current_fs_time - time not stored */
463 inode->i_atime = CURRENT_TIME;
465 cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
467 cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
468 cFYI(0, ("Attributes came in as 0x%x", attr));
469 if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
470 inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
471 inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
474 /* set default mode. will override for dirs below */
475 if (atomic_read(&cifsInfo->inUse) == 0)
476 /* new inode, can safely set these fields */
477 inode->i_mode = cifs_sb->mnt_file_mode;
478 else /* since we set the inode type below we need to mask off
479 to avoid strange results if type changes and both
481 inode->i_mode &= ~S_IFMT;
482 /* if (attr & ATTR_REPARSE) */
483 /* We no longer handle these as symlinks because we could not
484 follow them due to the absolute path with drive letter */
485 if (attr & ATTR_DIRECTORY) {
486 /* override default perms since we do not do byte range locking
488 inode->i_mode = cifs_sb->mnt_dir_mode;
489 inode->i_mode |= S_IFDIR;
490 } else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
491 (cifsInfo->cifsAttrs & ATTR_SYSTEM) &&
492 /* No need to le64 convert size of zero */
493 (pfindData->EndOfFile == 0)) {
494 inode->i_mode = cifs_sb->mnt_file_mode;
495 inode->i_mode |= S_IFIFO;
496 /* BB Finish for SFU style symlinks and devices */
497 } else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
498 (cifsInfo->cifsAttrs & ATTR_SYSTEM)) {
499 if (decode_sfu_inode(inode,
500 le64_to_cpu(pfindData->EndOfFile),
503 cFYI(1, ("Unrecognized sfu inode type"));
505 cFYI(1, ("sfu mode 0%o", inode->i_mode));
507 inode->i_mode |= S_IFREG;
508 /* treat the dos attribute of read-only as read-only
510 if (cifsInfo->cifsAttrs & ATTR_READONLY)
511 inode->i_mode &= ~(S_IWUGO);
512 else if ((inode->i_mode & S_IWUGO) == 0)
513 /* the ATTR_READONLY flag may have been */
514 /* changed on server -- set any w bits */
515 /* allowed by mnt_file_mode */
516 inode->i_mode |= (S_IWUGO &
517 cifs_sb->mnt_file_mode);
518 /* BB add code here -
519 validate if device or weird share or device type? */
522 spin_lock(&inode->i_lock);
523 if (is_size_safe_to_change(cifsInfo,
524 le64_to_cpu(pfindData->EndOfFile))) {
525 /* can not safely shrink the file size here if the
526 client is writing to it due to potential races */
527 i_size_write(inode, le64_to_cpu(pfindData->EndOfFile));
529 /* 512 bytes (2**9) is the fake blocksize that must be
530 used for this calculation */
531 inode->i_blocks = (512 - 1 + le64_to_cpu(
532 pfindData->AllocationSize)) >> 9;
534 spin_unlock(&inode->i_lock);
536 inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);
538 /* BB fill in uid and gid here? with help from winbind?
539 or retrieve from NTFS stream extended attribute */
540 #ifdef CONFIG_CIFS_EXPERIMENTAL
541 /* fill in 0777 bits from ACL */
542 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
543 cFYI(1, ("Getting mode bits from ACL"));
544 acl_to_uid_mode(inode, search_path);
547 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
548 /* fill in remaining high mode bits e.g. SUID, VTX */
549 get_sfu_mode(inode, search_path, cifs_sb, xid);
550 } else if (atomic_read(&cifsInfo->inUse) == 0) {
551 inode->i_uid = cifs_sb->mnt_uid;
552 inode->i_gid = cifs_sb->mnt_gid;
553 /* set so we do not keep refreshing these fields with
554 bad data after user has changed them in memory */
555 atomic_set(&cifsInfo->inUse, 1);
564 static const struct inode_operations cifs_ipc_inode_ops = {
565 .lookup = cifs_lookup,
568 /* gets root inode */
569 struct inode *cifs_iget(struct super_block *sb, unsigned long ino)
572 struct cifs_sb_info *cifs_sb;
576 inode = iget_locked(sb, ino);
578 return ERR_PTR(-ENOMEM);
579 if (!(inode->i_state & I_NEW))
582 cifs_sb = CIFS_SB(inode->i_sb);
585 if (cifs_sb->tcon->unix_ext)
586 rc = cifs_get_inode_info_unix(&inode, "", inode->i_sb, xid);
588 rc = cifs_get_inode_info(&inode, "", NULL, inode->i_sb, xid);
589 if (rc && cifs_sb->tcon->ipc) {
590 cFYI(1, ("ipc connection - fake read inode"));
591 inode->i_mode |= S_IFDIR;
593 inode->i_op = &cifs_ipc_inode_ops;
594 inode->i_fop = &simple_dir_operations;
595 inode->i_uid = cifs_sb->mnt_uid;
596 inode->i_gid = cifs_sb->mnt_gid;
602 unlock_new_inode(inode);
604 /* can not call macro FreeXid here since in a void func
605 * TODO: This is no longer true
611 int cifs_unlink(struct inode *inode, struct dentry *direntry)
615 struct cifs_sb_info *cifs_sb;
616 struct cifsTconInfo *pTcon;
617 char *full_path = NULL;
618 struct cifsInodeInfo *cifsInode;
619 FILE_BASIC_INFO *pinfo_buf;
621 cFYI(1, ("cifs_unlink, inode = 0x%p", inode));
626 cifs_sb = CIFS_SB(inode->i_sb);
628 cifs_sb = CIFS_SB(direntry->d_sb);
629 pTcon = cifs_sb->tcon;
631 /* Unlink can be called from rename so we can not grab the sem here
632 since we deadlock otherwise */
633 /* mutex_lock(&direntry->d_sb->s_vfs_rename_mutex);*/
634 full_path = build_path_from_dentry(direntry);
635 /* mutex_unlock(&direntry->d_sb->s_vfs_rename_mutex);*/
636 if (full_path == NULL) {
641 if ((pTcon->ses->capabilities & CAP_UNIX) &&
642 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
643 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
644 rc = CIFSPOSIXDelFile(xid, pTcon, full_path,
645 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
646 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
647 cFYI(1, ("posix del rc %d", rc));
648 if ((rc == 0) || (rc == -ENOENT))
649 goto psx_del_no_retry;
652 rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls,
653 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
656 if (direntry->d_inode)
657 drop_nlink(direntry->d_inode);
658 } else if (rc == -ENOENT) {
660 } else if (rc == -ETXTBSY) {
664 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,
665 CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,
666 &netfid, &oplock, NULL, cifs_sb->local_nls,
667 cifs_sb->mnt_cifs_flags &
668 CIFS_MOUNT_MAP_SPECIAL_CHR);
670 CIFSSMBRenameOpenFile(xid, pTcon, netfid, NULL,
672 cifs_sb->mnt_cifs_flags &
673 CIFS_MOUNT_MAP_SPECIAL_CHR);
674 CIFSSMBClose(xid, pTcon, netfid);
675 if (direntry->d_inode)
676 drop_nlink(direntry->d_inode);
678 } else if (rc == -EACCES) {
679 /* try only if r/o attribute set in local lookup data? */
680 pinfo_buf = kzalloc(sizeof(FILE_BASIC_INFO), GFP_KERNEL);
682 /* ATTRS set to normal clears r/o bit */
683 pinfo_buf->Attributes = cpu_to_le32(ATTR_NORMAL);
684 if (!(pTcon->ses->flags & CIFS_SES_NT4))
685 rc = CIFSSMBSetTimes(xid, pTcon, full_path,
688 cifs_sb->mnt_cifs_flags &
689 CIFS_MOUNT_MAP_SPECIAL_CHR);
693 if (rc == -EOPNOTSUPP) {
696 /* rc = CIFSSMBSetAttrLegacy(xid, pTcon,
700 For some strange reason it seems that NT4 eats the
701 old setattr call without actually setting the
702 attributes so on to the third attempted workaround
705 /* BB could scan to see if we already have it open
706 and pass in pid of opener to function */
707 rc = CIFSSMBOpen(xid, pTcon, full_path,
708 FILE_OPEN, SYNCHRONIZE |
709 FILE_WRITE_ATTRIBUTES, 0,
710 &netfid, &oplock, NULL,
712 cifs_sb->mnt_cifs_flags &
713 CIFS_MOUNT_MAP_SPECIAL_CHR);
715 rc = CIFSSMBSetFileTimes(xid, pTcon,
718 CIFSSMBClose(xid, pTcon, netfid);
724 rc = CIFSSMBDelFile(xid, pTcon, full_path,
726 cifs_sb->mnt_cifs_flags &
727 CIFS_MOUNT_MAP_SPECIAL_CHR);
729 if (direntry->d_inode)
730 drop_nlink(direntry->d_inode);
731 } else if (rc == -ETXTBSY) {
735 rc = CIFSSMBOpen(xid, pTcon, full_path,
738 CREATE_DELETE_ON_CLOSE,
739 &netfid, &oplock, NULL,
741 cifs_sb->mnt_cifs_flags &
742 CIFS_MOUNT_MAP_SPECIAL_CHR);
744 CIFSSMBRenameOpenFile(xid, pTcon,
747 cifs_sb->mnt_cifs_flags &
748 CIFS_MOUNT_MAP_SPECIAL_CHR);
749 CIFSSMBClose(xid, pTcon, netfid);
750 if (direntry->d_inode)
751 drop_nlink(direntry->d_inode);
753 /* BB if rc = -ETXTBUSY goto the rename logic BB */
757 if (direntry->d_inode) {
758 cifsInode = CIFS_I(direntry->d_inode);
759 cifsInode->time = 0; /* will force revalidate to get info
761 direntry->d_inode->i_ctime = current_fs_time(inode->i_sb);
764 inode->i_ctime = inode->i_mtime = current_fs_time(inode->i_sb);
765 cifsInode = CIFS_I(inode);
766 cifsInode->time = 0; /* force revalidate of dir as well */
774 static void posix_fill_in_inode(struct inode *tmp_inode,
775 FILE_UNIX_BASIC_INFO *pData, int *pobject_type, int isNewInode)
778 struct timespec local_mtime;
780 struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
781 struct cifs_sb_info *cifs_sb = CIFS_SB(tmp_inode->i_sb);
783 __u32 type = le32_to_cpu(pData->Type);
784 __u64 num_of_bytes = le64_to_cpu(pData->NumOfBytes);
785 __u64 end_of_file = le64_to_cpu(pData->EndOfFile);
786 cifsInfo->time = jiffies;
787 atomic_inc(&cifsInfo->inUse);
789 /* save mtime and size */
790 local_mtime = tmp_inode->i_mtime;
791 local_size = tmp_inode->i_size;
794 cifs_NTtimeToUnix(le64_to_cpu(pData->LastAccessTime));
796 cifs_NTtimeToUnix(le64_to_cpu(pData->LastModificationTime));
798 cifs_NTtimeToUnix(le64_to_cpu(pData->LastStatusChange));
800 tmp_inode->i_mode = le64_to_cpu(pData->Permissions);
801 /* since we set the inode type below we need to mask off type
802 to avoid strange results if bits above were corrupt */
803 tmp_inode->i_mode &= ~S_IFMT;
804 if (type == UNIX_FILE) {
805 *pobject_type = DT_REG;
806 tmp_inode->i_mode |= S_IFREG;
807 } else if (type == UNIX_SYMLINK) {
808 *pobject_type = DT_LNK;
809 tmp_inode->i_mode |= S_IFLNK;
810 } else if (type == UNIX_DIR) {
811 *pobject_type = DT_DIR;
812 tmp_inode->i_mode |= S_IFDIR;
813 } else if (type == UNIX_CHARDEV) {
814 *pobject_type = DT_CHR;
815 tmp_inode->i_mode |= S_IFCHR;
816 tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
817 le64_to_cpu(pData->DevMinor) & MINORMASK);
818 } else if (type == UNIX_BLOCKDEV) {
819 *pobject_type = DT_BLK;
820 tmp_inode->i_mode |= S_IFBLK;
821 tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
822 le64_to_cpu(pData->DevMinor) & MINORMASK);
823 } else if (type == UNIX_FIFO) {
824 *pobject_type = DT_FIFO;
825 tmp_inode->i_mode |= S_IFIFO;
826 } else if (type == UNIX_SOCKET) {
827 *pobject_type = DT_SOCK;
828 tmp_inode->i_mode |= S_IFSOCK;
830 /* safest to just call it a file */
831 *pobject_type = DT_REG;
832 tmp_inode->i_mode |= S_IFREG;
833 cFYI(1, ("unknown inode type %d", type));
836 cFYI(DBG2, ("object type: %d", type));
837 tmp_inode->i_uid = le64_to_cpu(pData->Uid);
838 tmp_inode->i_gid = le64_to_cpu(pData->Gid);
839 tmp_inode->i_nlink = le64_to_cpu(pData->Nlinks);
841 spin_lock(&tmp_inode->i_lock);
842 if (is_size_safe_to_change(cifsInfo, end_of_file)) {
843 /* can not safely change the file size here if the
844 client is writing to it due to potential races */
845 i_size_write(tmp_inode, end_of_file);
847 /* 512 bytes (2**9) is the fake blocksize that must be used */
848 /* for this calculation, not the real blocksize */
849 tmp_inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
851 spin_unlock(&tmp_inode->i_lock);
853 if (S_ISREG(tmp_inode->i_mode)) {
854 cFYI(1, ("File inode"));
855 tmp_inode->i_op = &cifs_file_inode_ops;
857 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
858 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
859 tmp_inode->i_fop = &cifs_file_direct_nobrl_ops;
861 tmp_inode->i_fop = &cifs_file_direct_ops;
863 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
864 tmp_inode->i_fop = &cifs_file_nobrl_ops;
866 tmp_inode->i_fop = &cifs_file_ops;
868 if ((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
869 (cifs_sb->tcon->ses->server->maxBuf <
870 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE))
871 tmp_inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
873 tmp_inode->i_data.a_ops = &cifs_addr_ops;
876 return; /* No sense invalidating pages for new inode
877 since we we have not started caching
878 readahead file data yet */
880 if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
881 (local_size == tmp_inode->i_size)) {
882 cFYI(1, ("inode exists but unchanged"));
884 /* file may have changed on server */
885 cFYI(1, ("invalidate inode, readdir detected change"));
886 invalidate_remote_inode(tmp_inode);
888 } else if (S_ISDIR(tmp_inode->i_mode)) {
889 cFYI(1, ("Directory inode"));
890 tmp_inode->i_op = &cifs_dir_inode_ops;
891 tmp_inode->i_fop = &cifs_dir_ops;
892 } else if (S_ISLNK(tmp_inode->i_mode)) {
893 cFYI(1, ("Symbolic Link inode"));
894 tmp_inode->i_op = &cifs_symlink_inode_ops;
895 /* tmp_inode->i_fop = *//* do not need to set to anything */
897 cFYI(1, ("Special inode"));
898 init_special_inode(tmp_inode, tmp_inode->i_mode,
903 int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
907 struct cifs_sb_info *cifs_sb;
908 struct cifsTconInfo *pTcon;
909 char *full_path = NULL;
910 struct inode *newinode = NULL;
912 cFYI(1, ("In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode));
916 cifs_sb = CIFS_SB(inode->i_sb);
917 pTcon = cifs_sb->tcon;
919 full_path = build_path_from_dentry(direntry);
920 if (full_path == NULL) {
925 if ((pTcon->ses->capabilities & CAP_UNIX) &&
926 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
927 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
929 FILE_UNIX_BASIC_INFO *pInfo =
930 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
936 mode &= ~current->fs->umask;
937 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
938 mode, NULL /* netfid */, pInfo, &oplock,
939 full_path, cifs_sb->local_nls,
940 cifs_sb->mnt_cifs_flags &
941 CIFS_MOUNT_MAP_SPECIAL_CHR);
942 if (rc == -EOPNOTSUPP) {
944 goto mkdir_retry_old;
946 cFYI(1, ("posix mkdir returned 0x%x", rc));
950 if (pInfo->Type == cpu_to_le32(-1)) {
951 /* no return info, go query for it */
955 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
959 direntry->d_op = &cifs_ci_dentry_ops;
961 direntry->d_op = &cifs_dentry_ops;
963 newinode = new_inode(inode->i_sb);
964 if (newinode == NULL) {
968 /* Is an i_ino of zero legal? */
969 /* Are there sanity checks we can use to ensure that
970 the server is really filling in that field? */
971 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
973 (unsigned long)pInfo->UniqueId;
974 } /* note ino incremented to unique num in new_inode */
975 if (inode->i_sb->s_flags & MS_NOATIME)
976 newinode->i_flags |= S_NOATIME | S_NOCMTIME;
977 newinode->i_nlink = 2;
979 insert_inode_hash(newinode);
980 d_instantiate(direntry, newinode);
982 /* we already checked in POSIXCreate whether
983 frame was long enough */
984 posix_fill_in_inode(direntry->d_inode,
985 pInfo, &obj_type, 1 /* NewInode */);
986 #ifdef CONFIG_CIFS_DEBUG2
987 cFYI(1, ("instantiated dentry %p %s to inode %p",
988 direntry, direntry->d_name.name, newinode));
990 if (newinode->i_nlink != 2)
991 cFYI(1, ("unexpected number of links %d",
999 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1000 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1001 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1003 cFYI(1, ("cifs_mkdir returned 0x%x", rc));
1008 if (pTcon->unix_ext)
1009 rc = cifs_get_inode_info_unix(&newinode, full_path,
1012 rc = cifs_get_inode_info(&newinode, full_path, NULL,
1016 direntry->d_op = &cifs_ci_dentry_ops;
1018 direntry->d_op = &cifs_dentry_ops;
1019 d_instantiate(direntry, newinode);
1020 /* setting nlink not necessary except in cases where we
1021 * failed to get it from the server or was set bogus */
1022 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
1023 direntry->d_inode->i_nlink = 2;
1024 if (pTcon->unix_ext) {
1025 mode &= ~current->fs->umask;
1026 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1027 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
1029 (__u64)current->fsuid,
1030 (__u64)current->fsgid,
1033 cifs_sb->mnt_cifs_flags &
1034 CIFS_MOUNT_MAP_SPECIAL_CHR);
1036 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
1038 (__u64)-1, 0 /* dev_t */,
1040 cifs_sb->mnt_cifs_flags &
1041 CIFS_MOUNT_MAP_SPECIAL_CHR);
1044 /* BB to be implemented via Windows secrty descriptors
1045 eg CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
1046 -1, -1, local_nls); */
1047 if (direntry->d_inode) {
1048 direntry->d_inode->i_mode = mode;
1049 direntry->d_inode->i_mode |= S_IFDIR;
1050 if (cifs_sb->mnt_cifs_flags &
1051 CIFS_MOUNT_SET_UID) {
1052 direntry->d_inode->i_uid =
1054 direntry->d_inode->i_gid =
1066 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1070 struct cifs_sb_info *cifs_sb;
1071 struct cifsTconInfo *pTcon;
1072 char *full_path = NULL;
1073 struct cifsInodeInfo *cifsInode;
1075 cFYI(1, ("cifs_rmdir, inode = 0x%p", inode));
1079 cifs_sb = CIFS_SB(inode->i_sb);
1080 pTcon = cifs_sb->tcon;
1082 full_path = build_path_from_dentry(direntry);
1083 if (full_path == NULL) {
1088 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1089 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1093 spin_lock(&direntry->d_inode->i_lock);
1094 i_size_write(direntry->d_inode, 0);
1095 clear_nlink(direntry->d_inode);
1096 spin_unlock(&direntry->d_inode->i_lock);
1099 cifsInode = CIFS_I(direntry->d_inode);
1100 cifsInode->time = 0; /* force revalidate to go get info when
1102 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1103 current_fs_time(inode->i_sb);
1110 int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
1111 struct inode *target_inode, struct dentry *target_direntry)
1115 struct cifs_sb_info *cifs_sb_source;
1116 struct cifs_sb_info *cifs_sb_target;
1117 struct cifsTconInfo *pTcon;
1123 cifs_sb_target = CIFS_SB(target_inode->i_sb);
1124 cifs_sb_source = CIFS_SB(source_inode->i_sb);
1125 pTcon = cifs_sb_source->tcon;
1127 if (pTcon != cifs_sb_target->tcon) {
1129 return -EXDEV; /* BB actually could be allowed if same server,
1130 but different share.
1131 Might eventually add support for this */
1134 /* we already have the rename sem so we do not need to grab it again
1135 here to protect the path integrity */
1136 fromName = build_path_from_dentry(source_direntry);
1137 toName = build_path_from_dentry(target_direntry);
1138 if ((fromName == NULL) || (toName == NULL)) {
1140 goto cifs_rename_exit;
1143 rc = CIFSSMBRename(xid, pTcon, fromName, toName,
1144 cifs_sb_source->local_nls,
1145 cifs_sb_source->mnt_cifs_flags &
1146 CIFS_MOUNT_MAP_SPECIAL_CHR);
1147 if (rc == -EEXIST) {
1148 /* check if they are the same file because rename of hardlinked
1150 FILE_UNIX_BASIC_INFO *info_buf_source;
1151 FILE_UNIX_BASIC_INFO *info_buf_target;
1154 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1155 if (info_buf_source != NULL) {
1156 info_buf_target = info_buf_source + 1;
1157 if (pTcon->unix_ext)
1158 rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName,
1160 cifs_sb_source->local_nls,
1161 cifs_sb_source->mnt_cifs_flags &
1162 CIFS_MOUNT_MAP_SPECIAL_CHR);
1163 /* else rc is still EEXIST so will fall through to
1164 unlink the target and retry rename */
1166 rc = CIFSSMBUnixQPathInfo(xid, pTcon, toName,
1168 cifs_sb_target->local_nls,
1169 /* remap based on source sb */
1170 cifs_sb_source->mnt_cifs_flags &
1171 CIFS_MOUNT_MAP_SPECIAL_CHR);
1174 (info_buf_source->UniqueId ==
1175 info_buf_target->UniqueId)) {
1176 /* do not rename since the files are hardlinked which
1179 /* we either can not tell the files are hardlinked
1180 (as with Windows servers) or files are not
1181 hardlinked so delete the target manually before
1182 renaming to follow POSIX rather than Windows
1184 cifs_unlink(target_inode, target_direntry);
1185 rc = CIFSSMBRename(xid, pTcon, fromName,
1187 cifs_sb_source->local_nls,
1188 cifs_sb_source->mnt_cifs_flags
1189 & CIFS_MOUNT_MAP_SPECIAL_CHR);
1191 kfree(info_buf_source);
1192 } /* if we can not get memory just leave rc as EEXIST */
1196 cFYI(1, ("rename rc %d", rc));
1198 if ((rc == -EIO) || (rc == -EEXIST)) {
1202 /* BB FIXME Is Generic Read correct for rename? */
1203 /* if renaming directory - we should not say CREATE_NOT_DIR,
1204 need to test renaming open directory, also GENERIC_READ
1205 might not right be right access to request */
1206 rc = CIFSSMBOpen(xid, pTcon, fromName, FILE_OPEN, GENERIC_READ,
1207 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1208 cifs_sb_source->local_nls,
1209 cifs_sb_source->mnt_cifs_flags &
1210 CIFS_MOUNT_MAP_SPECIAL_CHR);
1212 rc = CIFSSMBRenameOpenFile(xid, pTcon, netfid, toName,
1213 cifs_sb_source->local_nls,
1214 cifs_sb_source->mnt_cifs_flags &
1215 CIFS_MOUNT_MAP_SPECIAL_CHR);
1216 CIFSSMBClose(xid, pTcon, netfid);
1227 int cifs_revalidate(struct dentry *direntry)
1230 int rc = 0, wbrc = 0;
1232 struct cifs_sb_info *cifs_sb;
1233 struct cifsInodeInfo *cifsInode;
1235 struct timespec local_mtime;
1236 int invalidate_inode = FALSE;
1238 if (direntry->d_inode == NULL)
1241 cifsInode = CIFS_I(direntry->d_inode);
1243 if (cifsInode == NULL)
1246 /* no sense revalidating inode info on file that no one can write */
1247 if (CIFS_I(direntry->d_inode)->clientCanCacheRead)
1252 cifs_sb = CIFS_SB(direntry->d_sb);
1254 /* can not safely grab the rename sem here if rename calls revalidate
1255 since that would deadlock */
1256 full_path = build_path_from_dentry(direntry);
1257 if (full_path == NULL) {
1261 cFYI(1, ("Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1262 "jiffies %ld", full_path, direntry->d_inode,
1263 direntry->d_inode->i_count.counter, direntry,
1264 direntry->d_time, jiffies));
1266 if (cifsInode->time == 0) {
1267 /* was set to zero previously to force revalidate */
1268 } else if (time_before(jiffies, cifsInode->time + HZ) &&
1269 lookupCacheEnabled) {
1270 if ((S_ISREG(direntry->d_inode->i_mode) == 0) ||
1271 (direntry->d_inode->i_nlink == 1)) {
1276 cFYI(1, ("Have to revalidate file due to hardlinks"));
1280 /* save mtime and size */
1281 local_mtime = direntry->d_inode->i_mtime;
1282 local_size = direntry->d_inode->i_size;
1284 if (cifs_sb->tcon->unix_ext) {
1285 rc = cifs_get_inode_info_unix(&direntry->d_inode, full_path,
1286 direntry->d_sb, xid);
1288 cFYI(1, ("error on getting revalidate info %d", rc));
1289 /* if (rc != -ENOENT)
1290 rc = 0; */ /* BB should we cache info on
1294 rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
1295 direntry->d_sb, xid);
1297 cFYI(1, ("error on getting revalidate info %d", rc));
1298 /* if (rc != -ENOENT)
1299 rc = 0; */ /* BB should we cache info on
1303 /* should we remap certain errors, access denied?, to zero */
1305 /* if not oplocked, we invalidate inode pages if mtime or file size
1306 had changed on server */
1308 if (timespec_equal(&local_mtime, &direntry->d_inode->i_mtime) &&
1309 (local_size == direntry->d_inode->i_size)) {
1310 cFYI(1, ("cifs_revalidate - inode unchanged"));
1312 /* file may have changed on server */
1313 if (cifsInode->clientCanCacheRead) {
1314 /* no need to invalidate inode pages since we were the
1315 only ones who could have modified the file and the
1316 server copy is staler than ours */
1318 invalidate_inode = TRUE;
1322 /* can not grab this sem since kernel filesys locking documentation
1323 indicates i_mutex may be taken by the kernel on lookup and rename
1324 which could deadlock if we grab the i_mutex here as well */
1325 /* mutex_lock(&direntry->d_inode->i_mutex);*/
1326 /* need to write out dirty pages here */
1327 if (direntry->d_inode->i_mapping) {
1328 /* do we need to lock inode until after invalidate completes
1330 wbrc = filemap_fdatawrite(direntry->d_inode->i_mapping);
1332 CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
1334 if (invalidate_inode) {
1335 /* shrink_dcache not necessary now that cifs dentry ops
1336 are exported for negative dentries */
1337 /* if (S_ISDIR(direntry->d_inode->i_mode))
1338 shrink_dcache_parent(direntry); */
1339 if (S_ISREG(direntry->d_inode->i_mode)) {
1340 if (direntry->d_inode->i_mapping)
1341 wbrc = filemap_fdatawait(direntry->d_inode->i_mapping);
1343 CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
1344 /* may eventually have to do this for open files too */
1345 if (list_empty(&(cifsInode->openFileList))) {
1346 /* changed on server - flush read ahead pages */
1347 cFYI(1, ("Invalidating read ahead data on "
1349 invalidate_remote_inode(direntry->d_inode);
1353 /* mutex_unlock(&direntry->d_inode->i_mutex); */
1360 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1363 int err = cifs_revalidate(dentry);
1365 generic_fillattr(dentry->d_inode, stat);
1366 stat->blksize = CIFS_MAX_MSGSIZE;
1371 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1373 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1374 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1378 page = grab_cache_page(mapping, index);
1382 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1384 page_cache_release(page);
1388 static int cifs_vmtruncate(struct inode *inode, loff_t offset)
1390 struct address_space *mapping = inode->i_mapping;
1391 unsigned long limit;
1393 spin_lock(&inode->i_lock);
1394 if (inode->i_size < offset)
1397 * truncation of in-use swapfiles is disallowed - it would cause
1398 * subsequent swapout to scribble on the now-freed blocks.
1400 if (IS_SWAPFILE(inode)) {
1401 spin_unlock(&inode->i_lock);
1404 i_size_write(inode, offset);
1405 spin_unlock(&inode->i_lock);
1407 * unmap_mapping_range is called twice, first simply for efficiency
1408 * so that truncate_inode_pages does fewer single-page unmaps. However
1409 * after this first call, and before truncate_inode_pages finishes,
1410 * it is possible for private pages to be COWed, which remain after
1411 * truncate_inode_pages finishes, hence the second unmap_mapping_range
1412 * call must be made for correctness.
1414 unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
1415 truncate_inode_pages(mapping, offset);
1416 unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
1420 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
1421 if (limit != RLIM_INFINITY && offset > limit) {
1422 spin_unlock(&inode->i_lock);
1425 if (offset > inode->i_sb->s_maxbytes) {
1426 spin_unlock(&inode->i_lock);
1429 i_size_write(inode, offset);
1430 spin_unlock(&inode->i_lock);
1432 if (inode->i_op && inode->i_op->truncate)
1433 inode->i_op->truncate(inode);
1436 send_sig(SIGXFSZ, current, 0);
1443 int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
1446 struct cifs_sb_info *cifs_sb;
1447 struct cifsTconInfo *pTcon;
1448 char *full_path = NULL;
1450 struct cifsFileInfo *open_file = NULL;
1451 FILE_BASIC_INFO time_buf;
1452 int set_time = FALSE;
1453 int set_dosattr = FALSE;
1454 __u64 mode = 0xFFFFFFFFFFFFFFFFULL;
1455 __u64 uid = 0xFFFFFFFFFFFFFFFFULL;
1456 __u64 gid = 0xFFFFFFFFFFFFFFFFULL;
1457 struct cifsInodeInfo *cifsInode;
1461 cFYI(1, ("setattr on file %s attrs->iavalid 0x%x",
1462 direntry->d_name.name, attrs->ia_valid));
1464 cifs_sb = CIFS_SB(direntry->d_inode->i_sb);
1465 pTcon = cifs_sb->tcon;
1467 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1468 /* check if we have permission to change attrs */
1469 rc = inode_change_ok(direntry->d_inode, attrs);
1477 full_path = build_path_from_dentry(direntry);
1478 if (full_path == NULL) {
1482 cifsInode = CIFS_I(direntry->d_inode);
1484 /* BB check if we need to refresh inode from server now ? BB */
1486 if (attrs->ia_valid & ATTR_SIZE) {
1488 Flush data before changing file size on server. If the
1489 flush returns error, store it to report later and continue.
1490 BB: This should be smarter. Why bother flushing pages that
1491 will be truncated anyway? Also, should we error out here if
1492 the flush returns error?
1494 rc = filemap_write_and_wait(direntry->d_inode->i_mapping);
1496 CIFS_I(direntry->d_inode)->write_behind_rc = rc;
1500 /* To avoid spurious oplock breaks from server, in the case of
1501 inodes that we already have open, avoid doing path based
1502 setting of file size if we can do it by handle.
1503 This keeps our caching token (oplock) and avoids timeouts
1504 when the local oplock break takes longer to flush
1505 writebehind data than the SMB timeout for the SetPathInfo
1506 request would allow */
1508 open_file = find_writable_file(cifsInode);
1510 __u16 nfid = open_file->netfid;
1511 __u32 npid = open_file->pid;
1512 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size,
1514 atomic_dec(&open_file->wrtPending);
1515 cFYI(1, ("SetFSize for attrs rc = %d", rc));
1516 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1517 unsigned int bytes_written;
1518 rc = CIFSSMBWrite(xid, pTcon,
1519 nfid, 0, attrs->ia_size,
1520 &bytes_written, NULL, NULL,
1521 1 /* 45 seconds */);
1522 cFYI(1, ("Wrt seteof rc %d", rc));
1528 /* Set file size by pathname rather than by handle
1529 either because no valid, writeable file handle for
1530 it was found or because there was an error setting
1532 rc = CIFSSMBSetEOF(xid, pTcon, full_path,
1533 attrs->ia_size, FALSE,
1535 cifs_sb->mnt_cifs_flags &
1536 CIFS_MOUNT_MAP_SPECIAL_CHR);
1537 cFYI(1, ("SetEOF by path (setattrs) rc = %d", rc));
1538 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1542 rc = SMBLegacyOpen(xid, pTcon, full_path,
1544 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1545 CREATE_NOT_DIR, &netfid, &oplock,
1546 NULL, cifs_sb->local_nls,
1547 cifs_sb->mnt_cifs_flags &
1548 CIFS_MOUNT_MAP_SPECIAL_CHR);
1550 unsigned int bytes_written;
1551 rc = CIFSSMBWrite(xid, pTcon,
1554 &bytes_written, NULL,
1555 NULL, 1 /* 45 sec */);
1556 cFYI(1, ("wrt seteof rc %d", rc));
1557 CIFSSMBClose(xid, pTcon, netfid);
1563 /* Server is ok setting allocation size implicitly - no need
1565 CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size, TRUE,
1566 cifs_sb->local_nls);
1570 rc = cifs_vmtruncate(direntry->d_inode, attrs->ia_size);
1571 cifs_truncate_page(direntry->d_inode->i_mapping,
1572 direntry->d_inode->i_size);
1574 goto cifs_setattr_exit;
1576 if (attrs->ia_valid & ATTR_UID) {
1577 cFYI(1, ("UID changed to %d", attrs->ia_uid));
1578 uid = attrs->ia_uid;
1580 if (attrs->ia_valid & ATTR_GID) {
1581 cFYI(1, ("GID changed to %d", attrs->ia_gid));
1582 gid = attrs->ia_gid;
1585 time_buf.Attributes = 0;
1587 /* skip mode change if it's just for clearing setuid/setgid */
1588 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1589 attrs->ia_valid &= ~ATTR_MODE;
1591 if (attrs->ia_valid & ATTR_MODE) {
1592 cFYI(1, ("Mode changed to 0x%x", attrs->ia_mode));
1593 mode = attrs->ia_mode;
1596 if ((pTcon->unix_ext)
1597 && (attrs->ia_valid & (ATTR_MODE | ATTR_GID | ATTR_UID)))
1598 rc = CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode, uid, gid,
1599 0 /* dev_t */, cifs_sb->local_nls,
1600 cifs_sb->mnt_cifs_flags &
1601 CIFS_MOUNT_MAP_SPECIAL_CHR);
1602 else if (attrs->ia_valid & ATTR_MODE) {
1604 #ifdef CONFIG_CIFS_EXPERIMENTAL
1605 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
1606 rc = mode_to_acl(direntry->d_inode, full_path, mode);
1607 else if ((mode & S_IWUGO) == 0) {
1609 if ((mode & S_IWUGO) == 0) {
1612 if ((cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
1614 time_buf.Attributes =
1615 cpu_to_le32(cifsInode->cifsAttrs |
1618 } else if (cifsInode->cifsAttrs & ATTR_READONLY) {
1619 /* If file is readonly on server, we would
1620 not be able to write to it - so if any write
1621 bit is enabled for user or group or other we
1622 need to at least try to remove r/o dos attr */
1624 time_buf.Attributes = cpu_to_le32(cifsInode->cifsAttrs &
1626 /* Windows ignores set to zero */
1627 if (time_buf.Attributes == 0)
1628 time_buf.Attributes |= cpu_to_le32(ATTR_NORMAL);
1630 #ifdef CONFIG_CIFS_EXPERIMENTAL
1631 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
1632 mode_to_acl(direntry->d_inode, full_path, mode);
1636 if (attrs->ia_valid & ATTR_ATIME) {
1638 time_buf.LastAccessTime =
1639 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1641 time_buf.LastAccessTime = 0;
1643 if (attrs->ia_valid & ATTR_MTIME) {
1645 time_buf.LastWriteTime =
1646 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1648 time_buf.LastWriteTime = 0;
1649 /* Do not set ctime explicitly unless other time
1650 stamps are changed explicitly (i.e. by utime()
1651 since we would then have a mix of client and
1654 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1656 /* Although Samba throws this field away
1657 it may be useful to Windows - but we do
1658 not want to set ctime unless some other
1659 timestamp is changing */
1660 cFYI(1, ("CIFS - CTIME changed"));
1661 time_buf.ChangeTime =
1662 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1664 time_buf.ChangeTime = 0;
1666 if (set_time || set_dosattr) {
1667 time_buf.CreationTime = 0; /* do not change */
1668 /* In the future we should experiment - try setting timestamps
1669 via Handle (SetFileInfo) instead of by path */
1670 if (!(pTcon->ses->flags & CIFS_SES_NT4))
1671 rc = CIFSSMBSetTimes(xid, pTcon, full_path, &time_buf,
1673 cifs_sb->mnt_cifs_flags &
1674 CIFS_MOUNT_MAP_SPECIAL_CHR);
1678 if (rc == -EOPNOTSUPP) {
1682 cFYI(1, ("calling SetFileInfo since SetPathInfo for "
1683 "times not supported by this server"));
1684 /* BB we could scan to see if we already have it open
1685 and pass in pid of opener to function */
1686 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1687 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1688 CREATE_NOT_DIR, &netfid, &oplock,
1689 NULL, cifs_sb->local_nls,
1690 cifs_sb->mnt_cifs_flags &
1691 CIFS_MOUNT_MAP_SPECIAL_CHR);
1693 rc = CIFSSMBSetFileTimes(xid, pTcon, &time_buf,
1695 CIFSSMBClose(xid, pTcon, netfid);
1697 /* BB For even older servers we could convert time_buf
1698 into old DOS style which uses two second
1701 /* rc = CIFSSMBSetTimesLegacy(xid, pTcon, full_path,
1702 &time_buf, cifs_sb->local_nls); */
1705 /* Even if error on time set, no sense failing the call if
1706 the server would set the time to a reasonable value anyway,
1707 and this check ensures that we are not being called from
1708 sys_utimes in which case we ought to fail the call back to
1709 the user when the server rejects the call */
1710 if ((rc) && (attrs->ia_valid &
1711 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
1715 /* do not need local check to inode_check_ok since the server does
1718 rc = inode_setattr(direntry->d_inode, attrs);
1726 void cifs_delete_inode(struct inode *inode)
1728 cFYI(1, ("In cifs_delete_inode, inode = 0x%p", inode));
1729 /* may have to add back in if and when safe distributed caching of
1730 directories added e.g. via FindNotify */