4 * Copyright (C) International Business Machines Corp., 2002,2010
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/slab.h>
24 #include <linux/pagemap.h>
25 #include <asm/div64.h>
29 #include "cifsproto.h"
30 #include "cifs_debug.h"
31 #include "cifs_fs_sb.h"
35 static void cifs_set_ops(struct inode
*inode
, const bool is_dfs_referral
)
37 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
39 switch (inode
->i_mode
& S_IFMT
) {
41 inode
->i_op
= &cifs_file_inode_ops
;
42 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
43 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
44 inode
->i_fop
= &cifs_file_direct_nobrl_ops
;
46 inode
->i_fop
= &cifs_file_direct_ops
;
47 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
48 inode
->i_fop
= &cifs_file_nobrl_ops
;
49 else { /* not direct, send byte range locks */
50 inode
->i_fop
= &cifs_file_ops
;
54 /* check if server can support readpages */
55 if (cifs_sb
->tcon
->ses
->server
->maxBuf
<
56 PAGE_CACHE_SIZE
+ MAX_CIFS_HDR_SIZE
)
57 inode
->i_data
.a_ops
= &cifs_addr_ops_smallbuf
;
59 inode
->i_data
.a_ops
= &cifs_addr_ops
;
62 #ifdef CONFIG_CIFS_DFS_UPCALL
63 if (is_dfs_referral
) {
64 inode
->i_op
= &cifs_dfs_referral_inode_operations
;
66 #else /* NO DFS support, treat as a directory */
69 inode
->i_op
= &cifs_dir_inode_ops
;
70 inode
->i_fop
= &cifs_dir_ops
;
74 inode
->i_op
= &cifs_symlink_inode_ops
;
77 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
82 /* check inode attributes against fattr. If they don't match, tag the
83 * inode for cache invalidation
86 cifs_revalidate_cache(struct inode
*inode
, struct cifs_fattr
*fattr
)
88 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
90 cFYI(1, "%s: revalidating inode %llu", __func__
, cifs_i
->uniqueid
);
92 if (inode
->i_state
& I_NEW
) {
93 cFYI(1, "%s: inode %llu is new", __func__
, cifs_i
->uniqueid
);
97 /* don't bother with revalidation if we have an oplock */
98 if (cifs_i
->clientCanCacheRead
) {
99 cFYI(1, "%s: inode %llu is oplocked", __func__
,
104 /* revalidate if mtime or size have changed */
105 if (timespec_equal(&inode
->i_mtime
, &fattr
->cf_mtime
) &&
106 cifs_i
->server_eof
== fattr
->cf_eof
) {
107 cFYI(1, "%s: inode %llu is unchanged", __func__
,
112 cFYI(1, "%s: invalidating inode %llu mapping", __func__
,
114 cifs_i
->invalid_mapping
= true;
117 /* populate an inode with info from a cifs_fattr struct */
119 cifs_fattr_to_inode(struct inode
*inode
, struct cifs_fattr
*fattr
)
121 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
122 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
123 unsigned long oldtime
= cifs_i
->time
;
125 cifs_revalidate_cache(inode
, fattr
);
127 inode
->i_atime
= fattr
->cf_atime
;
128 inode
->i_mtime
= fattr
->cf_mtime
;
129 inode
->i_ctime
= fattr
->cf_ctime
;
130 inode
->i_rdev
= fattr
->cf_rdev
;
131 inode
->i_nlink
= fattr
->cf_nlink
;
132 inode
->i_uid
= fattr
->cf_uid
;
133 inode
->i_gid
= fattr
->cf_gid
;
135 /* if dynperm is set, don't clobber existing mode */
136 if (inode
->i_state
& I_NEW
||
137 !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
))
138 inode
->i_mode
= fattr
->cf_mode
;
140 cifs_i
->cifsAttrs
= fattr
->cf_cifsattrs
;
142 if (fattr
->cf_flags
& CIFS_FATTR_NEED_REVAL
)
145 cifs_i
->time
= jiffies
;
147 cFYI(1, "inode 0x%p old_time=%ld new_time=%ld", inode
,
148 oldtime
, cifs_i
->time
);
150 cifs_i
->delete_pending
= fattr
->cf_flags
& CIFS_FATTR_DELETE_PENDING
;
152 cifs_i
->server_eof
= fattr
->cf_eof
;
154 * Can't safely change the file size here if the client is writing to
155 * it due to potential races.
157 spin_lock(&inode
->i_lock
);
158 if (is_size_safe_to_change(cifs_i
, fattr
->cf_eof
)) {
159 i_size_write(inode
, fattr
->cf_eof
);
162 * i_blocks is not related to (i_size / i_blksize),
163 * but instead 512 byte (2**9) size is required for
164 * calculating num blocks.
166 inode
->i_blocks
= (512 - 1 + fattr
->cf_bytes
) >> 9;
168 spin_unlock(&inode
->i_lock
);
170 cifs_set_ops(inode
, fattr
->cf_flags
& CIFS_FATTR_DFS_REFERRAL
);
174 cifs_fill_uniqueid(struct super_block
*sb
, struct cifs_fattr
*fattr
)
176 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
178 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)
181 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
184 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
186 cifs_unix_basic_to_fattr(struct cifs_fattr
*fattr
, FILE_UNIX_BASIC_INFO
*info
,
187 struct cifs_sb_info
*cifs_sb
)
189 memset(fattr
, 0, sizeof(*fattr
));
190 fattr
->cf_uniqueid
= le64_to_cpu(info
->UniqueId
);
191 fattr
->cf_bytes
= le64_to_cpu(info
->NumOfBytes
);
192 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
194 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
195 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastModificationTime
);
196 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->LastStatusChange
);
197 fattr
->cf_mode
= le64_to_cpu(info
->Permissions
);
200 * Since we set the inode type below we need to mask off
201 * to avoid strange results if bits set above.
203 fattr
->cf_mode
&= ~S_IFMT
;
204 switch (le32_to_cpu(info
->Type
)) {
206 fattr
->cf_mode
|= S_IFREG
;
207 fattr
->cf_dtype
= DT_REG
;
210 fattr
->cf_mode
|= S_IFLNK
;
211 fattr
->cf_dtype
= DT_LNK
;
214 fattr
->cf_mode
|= S_IFDIR
;
215 fattr
->cf_dtype
= DT_DIR
;
218 fattr
->cf_mode
|= S_IFCHR
;
219 fattr
->cf_dtype
= DT_CHR
;
220 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
221 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
224 fattr
->cf_mode
|= S_IFBLK
;
225 fattr
->cf_dtype
= DT_BLK
;
226 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
227 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
230 fattr
->cf_mode
|= S_IFIFO
;
231 fattr
->cf_dtype
= DT_FIFO
;
234 fattr
->cf_mode
|= S_IFSOCK
;
235 fattr
->cf_dtype
= DT_SOCK
;
238 /* safest to call it a file if we do not know */
239 fattr
->cf_mode
|= S_IFREG
;
240 fattr
->cf_dtype
= DT_REG
;
241 cFYI(1, "unknown type %d", le32_to_cpu(info
->Type
));
245 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
)
246 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
248 fattr
->cf_uid
= le64_to_cpu(info
->Uid
);
250 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
)
251 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
253 fattr
->cf_gid
= le64_to_cpu(info
->Gid
);
255 fattr
->cf_nlink
= le64_to_cpu(info
->Nlinks
);
259 * Fill a cifs_fattr struct with fake inode info.
261 * Needed to setup cifs_fattr data for the directory which is the
262 * junction to the new submount (ie to setup the fake directory
263 * which represents a DFS referral).
266 cifs_create_dfs_fattr(struct cifs_fattr
*fattr
, struct super_block
*sb
)
268 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
270 cFYI(1, "creating fake fattr for DFS referral");
272 memset(fattr
, 0, sizeof(*fattr
));
273 fattr
->cf_mode
= S_IFDIR
| S_IXUGO
| S_IRWXU
;
274 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
275 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
276 fattr
->cf_atime
= CURRENT_TIME
;
277 fattr
->cf_ctime
= CURRENT_TIME
;
278 fattr
->cf_mtime
= CURRENT_TIME
;
280 fattr
->cf_flags
|= CIFS_FATTR_DFS_REFERRAL
;
283 int cifs_get_file_info_unix(struct file
*filp
)
287 FILE_UNIX_BASIC_INFO find_data
;
288 struct cifs_fattr fattr
;
289 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
290 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
291 struct cifsTconInfo
*tcon
= cifs_sb
->tcon
;
292 struct cifsFileInfo
*cfile
= filp
->private_data
;
295 rc
= CIFSSMBUnixQFileInfo(xid
, tcon
, cfile
->netfid
, &find_data
);
297 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
298 } else if (rc
== -EREMOTE
) {
299 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
303 cifs_fattr_to_inode(inode
, &fattr
);
308 int cifs_get_inode_info_unix(struct inode
**pinode
,
309 const unsigned char *full_path
,
310 struct super_block
*sb
, int xid
)
313 FILE_UNIX_BASIC_INFO find_data
;
314 struct cifs_fattr fattr
;
315 struct cifsTconInfo
*tcon
;
316 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
318 tcon
= cifs_sb
->tcon
;
319 cFYI(1, "Getting info on %s", full_path
);
321 /* could have done a find first instead but this returns more info */
322 rc
= CIFSSMBUnixQPathInfo(xid
, tcon
, full_path
, &find_data
,
323 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
324 CIFS_MOUNT_MAP_SPECIAL_CHR
);
327 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
328 } else if (rc
== -EREMOTE
) {
329 cifs_create_dfs_fattr(&fattr
, sb
);
335 if (*pinode
== NULL
) {
337 cifs_fill_uniqueid(sb
, &fattr
);
338 *pinode
= cifs_iget(sb
, &fattr
);
342 /* we already have inode, update it */
343 cifs_fattr_to_inode(*pinode
, &fattr
);
350 cifs_sfu_type(struct cifs_fattr
*fattr
, const unsigned char *path
,
351 struct cifs_sb_info
*cifs_sb
, int xid
)
356 struct cifsTconInfo
*pTcon
= cifs_sb
->tcon
;
358 unsigned int bytes_read
;
363 fattr
->cf_mode
&= ~S_IFMT
;
365 if (fattr
->cf_eof
== 0) {
366 fattr
->cf_mode
|= S_IFIFO
;
367 fattr
->cf_dtype
= DT_FIFO
;
369 } else if (fattr
->cf_eof
< 8) {
370 fattr
->cf_mode
|= S_IFREG
;
371 fattr
->cf_dtype
= DT_REG
;
372 return -EINVAL
; /* EOPNOTSUPP? */
375 rc
= CIFSSMBOpen(xid
, pTcon
, path
, FILE_OPEN
, GENERIC_READ
,
376 CREATE_NOT_DIR
, &netfid
, &oplock
, NULL
,
378 cifs_sb
->mnt_cifs_flags
&
379 CIFS_MOUNT_MAP_SPECIAL_CHR
);
381 int buf_type
= CIFS_NO_BUFFER
;
383 rc
= CIFSSMBRead(xid
, pTcon
, netfid
,
384 24 /* length */, 0 /* offset */,
385 &bytes_read
, &pbuf
, &buf_type
);
386 if ((rc
== 0) && (bytes_read
>= 8)) {
387 if (memcmp("IntxBLK", pbuf
, 8) == 0) {
388 cFYI(1, "Block device");
389 fattr
->cf_mode
|= S_IFBLK
;
390 fattr
->cf_dtype
= DT_BLK
;
391 if (bytes_read
== 24) {
392 /* we have enough to decode dev num */
393 __u64 mjr
; /* major */
394 __u64 mnr
; /* minor */
395 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
396 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
397 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
399 } else if (memcmp("IntxCHR", pbuf
, 8) == 0) {
400 cFYI(1, "Char device");
401 fattr
->cf_mode
|= S_IFCHR
;
402 fattr
->cf_dtype
= DT_CHR
;
403 if (bytes_read
== 24) {
404 /* we have enough to decode dev num */
405 __u64 mjr
; /* major */
406 __u64 mnr
; /* minor */
407 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
408 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
409 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
411 } else if (memcmp("IntxLNK", pbuf
, 7) == 0) {
413 fattr
->cf_mode
|= S_IFLNK
;
414 fattr
->cf_dtype
= DT_LNK
;
416 fattr
->cf_mode
|= S_IFREG
; /* file? */
417 fattr
->cf_dtype
= DT_REG
;
421 fattr
->cf_mode
|= S_IFREG
; /* then it is a file */
422 fattr
->cf_dtype
= DT_REG
;
423 rc
= -EOPNOTSUPP
; /* or some unknown SFU type */
425 CIFSSMBClose(xid
, pTcon
, netfid
);
430 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
432 static int cifs_sfu_mode(struct cifs_fattr
*fattr
, const unsigned char *path
,
433 struct cifs_sb_info
*cifs_sb
, int xid
)
435 #ifdef CONFIG_CIFS_XATTR
440 rc
= CIFSSMBQAllEAs(xid
, cifs_sb
->tcon
, path
, "SETFILEBITS",
441 ea_value
, 4 /* size of buf */, cifs_sb
->local_nls
,
442 cifs_sb
->mnt_cifs_flags
&
443 CIFS_MOUNT_MAP_SPECIAL_CHR
);
447 mode
= le32_to_cpu(*((__le32
*)ea_value
));
448 fattr
->cf_mode
&= ~SFBITS_MASK
;
449 cFYI(1, "special bits 0%o org mode 0%o", mode
,
451 fattr
->cf_mode
= (mode
& SFBITS_MASK
) | fattr
->cf_mode
;
452 cFYI(1, "special mode bits 0%o", mode
);
461 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
463 cifs_all_info_to_fattr(struct cifs_fattr
*fattr
, FILE_ALL_INFO
*info
,
464 struct cifs_sb_info
*cifs_sb
, bool adjust_tz
)
466 memset(fattr
, 0, sizeof(*fattr
));
467 fattr
->cf_cifsattrs
= le32_to_cpu(info
->Attributes
);
468 if (info
->DeletePending
)
469 fattr
->cf_flags
|= CIFS_FATTR_DELETE_PENDING
;
471 if (info
->LastAccessTime
)
472 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
474 fattr
->cf_atime
= CURRENT_TIME
;
476 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->ChangeTime
);
477 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastWriteTime
);
480 fattr
->cf_ctime
.tv_sec
+= cifs_sb
->tcon
->ses
->server
->timeAdj
;
481 fattr
->cf_mtime
.tv_sec
+= cifs_sb
->tcon
->ses
->server
->timeAdj
;
484 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
485 fattr
->cf_bytes
= le64_to_cpu(info
->AllocationSize
);
487 if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
) {
488 fattr
->cf_mode
= S_IFDIR
| cifs_sb
->mnt_dir_mode
;
489 fattr
->cf_dtype
= DT_DIR
;
491 fattr
->cf_mode
= S_IFREG
| cifs_sb
->mnt_file_mode
;
492 fattr
->cf_dtype
= DT_REG
;
494 /* clear write bits if ATTR_READONLY is set */
495 if (fattr
->cf_cifsattrs
& ATTR_READONLY
)
496 fattr
->cf_mode
&= ~(S_IWUGO
);
499 fattr
->cf_nlink
= le32_to_cpu(info
->NumberOfLinks
);
501 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
502 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
505 int cifs_get_file_info(struct file
*filp
)
509 FILE_ALL_INFO find_data
;
510 struct cifs_fattr fattr
;
511 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
512 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
513 struct cifsTconInfo
*tcon
= cifs_sb
->tcon
;
514 struct cifsFileInfo
*cfile
= filp
->private_data
;
517 rc
= CIFSSMBQFileInfo(xid
, tcon
, cfile
->netfid
, &find_data
);
518 if (rc
== -EOPNOTSUPP
|| rc
== -EINVAL
) {
520 CIFS_I(inode
)->time
= 0;
522 } else if (rc
== -EREMOTE
) {
523 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
529 * don't bother with SFU junk here -- just mark inode as needing
532 cifs_all_info_to_fattr(&fattr
, &find_data
, cifs_sb
, false);
533 fattr
.cf_uniqueid
= CIFS_I(inode
)->uniqueid
;
534 fattr
.cf_flags
|= CIFS_FATTR_NEED_REVAL
;
535 cifs_fattr_to_inode(inode
, &fattr
);
541 int cifs_get_inode_info(struct inode
**pinode
,
542 const unsigned char *full_path
, FILE_ALL_INFO
*pfindData
,
543 struct super_block
*sb
, int xid
, const __u16
*pfid
)
546 struct cifsTconInfo
*pTcon
;
547 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
549 bool adjustTZ
= false;
550 struct cifs_fattr fattr
;
552 pTcon
= cifs_sb
->tcon
;
553 cFYI(1, "Getting info on %s", full_path
);
555 if ((pfindData
== NULL
) && (*pinode
!= NULL
)) {
556 if (CIFS_I(*pinode
)->clientCanCacheRead
) {
557 cFYI(1, "No need to revalidate cached inode sizes");
562 /* if file info not passed in then get it from server */
563 if (pfindData
== NULL
) {
564 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
567 pfindData
= (FILE_ALL_INFO
*)buf
;
569 /* could do find first instead but this returns more info */
570 rc
= CIFSSMBQPathInfo(xid
, pTcon
, full_path
, pfindData
,
572 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
573 CIFS_MOUNT_MAP_SPECIAL_CHR
);
574 /* BB optimize code so we do not make the above call
575 when server claims no NT SMB support and the above call
576 failed at least once - set flag in tcon or mount */
577 if ((rc
== -EOPNOTSUPP
) || (rc
== -EINVAL
)) {
578 rc
= SMBQueryInformation(xid
, pTcon
, full_path
,
579 pfindData
, cifs_sb
->local_nls
,
580 cifs_sb
->mnt_cifs_flags
&
581 CIFS_MOUNT_MAP_SPECIAL_CHR
);
587 cifs_all_info_to_fattr(&fattr
, (FILE_ALL_INFO
*) pfindData
,
589 } else if (rc
== -EREMOTE
) {
590 cifs_create_dfs_fattr(&fattr
, sb
);
597 * If an inode wasn't passed in, then get the inode number
599 * Is an i_ino of zero legal? Can we use that to check if the server
600 * supports returning inode numbers? Are there other sanity checks we
601 * can use to ensure that the server is really filling in that field?
603 * We can not use the IndexNumber field by default from Windows or
604 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
605 * CIFS spec claims that this value is unique within the scope of a
606 * share, and the windows docs hint that it's actually unique
609 * There may be higher info levels that work but are there Windows
610 * server or network appliances for which IndexNumber field is not
613 if (*pinode
== NULL
) {
614 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) {
617 rc1
= CIFSGetSrvInodeNumber(xid
, pTcon
,
618 full_path
, &fattr
.cf_uniqueid
,
620 cifs_sb
->mnt_cifs_flags
&
621 CIFS_MOUNT_MAP_SPECIAL_CHR
);
622 if (rc1
|| !fattr
.cf_uniqueid
) {
623 cFYI(1, "GetSrvInodeNum rc %d", rc1
);
624 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
625 cifs_autodisable_serverino(cifs_sb
);
628 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
631 fattr
.cf_uniqueid
= CIFS_I(*pinode
)->uniqueid
;
634 /* query for SFU type info if supported and needed */
635 if (fattr
.cf_cifsattrs
& ATTR_SYSTEM
&&
636 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
) {
637 tmprc
= cifs_sfu_type(&fattr
, full_path
, cifs_sb
, xid
);
639 cFYI(1, "cifs_sfu_type failed: %d", tmprc
);
642 #ifdef CONFIG_CIFS_EXPERIMENTAL
643 /* fill in 0777 bits from ACL */
644 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
645 cFYI(1, "Getting mode bits from ACL");
646 cifs_acl_to_fattr(cifs_sb
, &fattr
, *pinode
, full_path
, pfid
);
650 /* fill in remaining high mode bits e.g. SUID, VTX */
651 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
)
652 cifs_sfu_mode(&fattr
, full_path
, cifs_sb
, xid
);
655 *pinode
= cifs_iget(sb
, &fattr
);
659 cifs_fattr_to_inode(*pinode
, &fattr
);
667 static const struct inode_operations cifs_ipc_inode_ops
= {
668 .lookup
= cifs_lookup
,
671 char *cifs_build_path_to_root(struct cifs_sb_info
*cifs_sb
)
673 int pplen
= cifs_sb
->prepathlen
;
675 char *full_path
= NULL
;
677 /* if no prefix path, simply set path to the root of share to "" */
679 full_path
= kmalloc(1, GFP_KERNEL
);
685 if (cifs_sb
->tcon
&& (cifs_sb
->tcon
->Flags
& SMB_SHARE_IS_IN_DFS
))
686 dfsplen
= strnlen(cifs_sb
->tcon
->treeName
, MAX_TREE_SIZE
+ 1);
690 full_path
= kmalloc(dfsplen
+ pplen
+ 1, GFP_KERNEL
);
691 if (full_path
== NULL
)
695 strncpy(full_path
, cifs_sb
->tcon
->treeName
, dfsplen
);
696 /* switch slash direction in prepath depending on whether
697 * windows or posix style path names
699 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
) {
701 for (i
= 0; i
< dfsplen
; i
++) {
702 if (full_path
[i
] == '\\')
707 strncpy(full_path
+ dfsplen
, cifs_sb
->prepath
, pplen
);
708 full_path
[dfsplen
+ pplen
] = 0; /* add trailing null */
713 cifs_find_inode(struct inode
*inode
, void *opaque
)
715 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
717 /* don't match inode with different uniqueid */
718 if (CIFS_I(inode
)->uniqueid
!= fattr
->cf_uniqueid
)
721 /* don't match inode of different type */
722 if ((inode
->i_mode
& S_IFMT
) != (fattr
->cf_mode
& S_IFMT
))
725 /* if it's not a directory or has no dentries, then flag it */
726 if (S_ISDIR(inode
->i_mode
) && !list_empty(&inode
->i_dentry
))
727 fattr
->cf_flags
|= CIFS_FATTR_INO_COLLISION
;
733 cifs_init_inode(struct inode
*inode
, void *opaque
)
735 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
737 CIFS_I(inode
)->uniqueid
= fattr
->cf_uniqueid
;
742 * walk dentry list for an inode and report whether it has aliases that
743 * are hashed. We use this to determine if a directory inode can actually
747 inode_has_hashed_dentries(struct inode
*inode
)
749 struct dentry
*dentry
;
751 spin_lock(&dcache_lock
);
752 list_for_each_entry(dentry
, &inode
->i_dentry
, d_alias
) {
753 if (!d_unhashed(dentry
) || IS_ROOT(dentry
)) {
754 spin_unlock(&dcache_lock
);
758 spin_unlock(&dcache_lock
);
762 /* Given fattrs, get a corresponding inode */
764 cifs_iget(struct super_block
*sb
, struct cifs_fattr
*fattr
)
770 cFYI(1, "looking for uniqueid=%llu", fattr
->cf_uniqueid
);
772 /* hash down to 32-bits on 32-bit arch */
773 hash
= cifs_uniqueid_to_ino_t(fattr
->cf_uniqueid
);
775 inode
= iget5_locked(sb
, hash
, cifs_find_inode
, cifs_init_inode
, fattr
);
777 /* was there a potentially problematic inode collision? */
778 if (fattr
->cf_flags
& CIFS_FATTR_INO_COLLISION
) {
779 fattr
->cf_flags
&= ~CIFS_FATTR_INO_COLLISION
;
781 if (inode_has_hashed_dentries(inode
)) {
782 cifs_autodisable_serverino(CIFS_SB(sb
));
784 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
785 goto retry_iget5_locked
;
789 cifs_fattr_to_inode(inode
, fattr
);
790 if (sb
->s_flags
& MS_NOATIME
)
791 inode
->i_flags
|= S_NOATIME
| S_NOCMTIME
;
792 if (inode
->i_state
& I_NEW
) {
794 if (S_ISREG(inode
->i_mode
))
795 inode
->i_data
.backing_dev_info
= sb
->s_bdi
;
796 #ifdef CONFIG_CIFS_FSCACHE
797 /* initialize per-inode cache cookie pointer */
798 CIFS_I(inode
)->fscache
= NULL
;
800 unlock_new_inode(inode
);
807 /* gets root inode */
808 struct inode
*cifs_root_iget(struct super_block
*sb
, unsigned long ino
)
811 struct cifs_sb_info
*cifs_sb
;
812 struct inode
*inode
= NULL
;
816 cifs_sb
= CIFS_SB(sb
);
817 full_path
= cifs_build_path_to_root(cifs_sb
);
818 if (full_path
== NULL
)
819 return ERR_PTR(-ENOMEM
);
822 if (cifs_sb
->tcon
->unix_ext
)
823 rc
= cifs_get_inode_info_unix(&inode
, full_path
, sb
, xid
);
825 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, sb
,
833 #ifdef CONFIG_CIFS_FSCACHE
834 /* populate tcon->resource_id */
835 cifs_sb
->tcon
->resource_id
= CIFS_I(inode
)->uniqueid
;
838 if (rc
&& cifs_sb
->tcon
->ipc
) {
839 cFYI(1, "ipc connection - fake read inode");
840 inode
->i_mode
|= S_IFDIR
;
842 inode
->i_op
= &cifs_ipc_inode_ops
;
843 inode
->i_fop
= &simple_dir_operations
;
844 inode
->i_uid
= cifs_sb
->mnt_uid
;
845 inode
->i_gid
= cifs_sb
->mnt_gid
;
853 /* can not call macro FreeXid here since in a void func
854 * TODO: This is no longer true
861 cifs_set_file_info(struct inode
*inode
, struct iattr
*attrs
, int xid
,
862 char *full_path
, __u32 dosattr
)
868 bool set_time
= false;
869 struct cifsFileInfo
*open_file
;
870 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
871 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
872 struct cifsTconInfo
*pTcon
= cifs_sb
->tcon
;
873 FILE_BASIC_INFO info_buf
;
878 if (attrs
->ia_valid
& ATTR_ATIME
) {
880 info_buf
.LastAccessTime
=
881 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_atime
));
883 info_buf
.LastAccessTime
= 0;
885 if (attrs
->ia_valid
& ATTR_MTIME
) {
887 info_buf
.LastWriteTime
=
888 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_mtime
));
890 info_buf
.LastWriteTime
= 0;
893 * Samba throws this field away, but windows may actually use it.
894 * Do not set ctime unless other time stamps are changed explicitly
895 * (i.e. by utimes()) since we would then have a mix of client and
898 if (set_time
&& (attrs
->ia_valid
& ATTR_CTIME
)) {
899 cFYI(1, "CIFS - CTIME changed");
900 info_buf
.ChangeTime
=
901 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_ctime
));
903 info_buf
.ChangeTime
= 0;
905 info_buf
.CreationTime
= 0; /* don't change */
906 info_buf
.Attributes
= cpu_to_le32(dosattr
);
909 * If the file is already open for write, just use that fileid
911 open_file
= find_writable_file(cifsInode
);
913 netfid
= open_file
->netfid
;
914 netpid
= open_file
->pid
;
915 goto set_via_filehandle
;
919 * NT4 apparently returns success on this call, but it doesn't
922 if (!(pTcon
->ses
->flags
& CIFS_SES_NT4
)) {
923 rc
= CIFSSMBSetPathInfo(xid
, pTcon
, full_path
,
924 &info_buf
, cifs_sb
->local_nls
,
925 cifs_sb
->mnt_cifs_flags
&
926 CIFS_MOUNT_MAP_SPECIAL_CHR
);
928 cifsInode
->cifsAttrs
= dosattr
;
930 } else if (rc
!= -EOPNOTSUPP
&& rc
!= -EINVAL
)
934 cFYI(1, "calling SetFileInfo since SetPathInfo for "
935 "times not supported by this server");
936 rc
= CIFSSMBOpen(xid
, pTcon
, full_path
, FILE_OPEN
,
937 SYNCHRONIZE
| FILE_WRITE_ATTRIBUTES
,
938 CREATE_NOT_DIR
, &netfid
, &oplock
,
939 NULL
, cifs_sb
->local_nls
,
940 cifs_sb
->mnt_cifs_flags
&
941 CIFS_MOUNT_MAP_SPECIAL_CHR
);
949 netpid
= current
->tgid
;
952 rc
= CIFSSMBSetFileInfo(xid
, pTcon
, &info_buf
, netfid
, netpid
);
954 cifsInode
->cifsAttrs
= dosattr
;
956 if (open_file
== NULL
)
957 CIFSSMBClose(xid
, pTcon
, netfid
);
959 cifsFileInfo_put(open_file
);
965 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
966 * and rename it to a random name that hopefully won't conflict with
970 cifs_rename_pending_delete(char *full_path
, struct dentry
*dentry
, int xid
)
975 struct inode
*inode
= dentry
->d_inode
;
976 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
977 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
978 struct cifsTconInfo
*tcon
= cifs_sb
->tcon
;
979 __u32 dosattr
, origattr
;
980 FILE_BASIC_INFO
*info_buf
= NULL
;
982 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, FILE_OPEN
,
983 DELETE
|FILE_WRITE_ATTRIBUTES
, CREATE_NOT_DIR
,
984 &netfid
, &oplock
, NULL
, cifs_sb
->local_nls
,
985 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
989 origattr
= cifsInode
->cifsAttrs
;
991 origattr
|= ATTR_NORMAL
;
993 dosattr
= origattr
& ~ATTR_READONLY
;
995 dosattr
|= ATTR_NORMAL
;
996 dosattr
|= ATTR_HIDDEN
;
998 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
999 if (dosattr
!= origattr
) {
1000 info_buf
= kzalloc(sizeof(*info_buf
), GFP_KERNEL
);
1001 if (info_buf
== NULL
) {
1005 info_buf
->Attributes
= cpu_to_le32(dosattr
);
1006 rc
= CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, netfid
,
1008 /* although we would like to mark the file hidden
1009 if that fails we will still try to rename it */
1011 cifsInode
->cifsAttrs
= dosattr
;
1013 dosattr
= origattr
; /* since not able to change them */
1016 /* rename the file */
1017 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, netfid
, NULL
, cifs_sb
->local_nls
,
1018 cifs_sb
->mnt_cifs_flags
&
1019 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1025 /* try to set DELETE_ON_CLOSE */
1026 if (!cifsInode
->delete_pending
) {
1027 rc
= CIFSSMBSetFileDisposition(xid
, tcon
, true, netfid
,
1035 cifsInode
->delete_pending
= true;
1039 CIFSSMBClose(xid
, tcon
, netfid
);
1045 * reset everything back to the original state. Don't bother
1046 * dealing with errors here since we can't do anything about
1050 CIFSSMBRenameOpenFile(xid
, tcon
, netfid
, dentry
->d_name
.name
,
1051 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1052 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1054 if (dosattr
!= origattr
) {
1055 info_buf
->Attributes
= cpu_to_le32(origattr
);
1056 if (!CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, netfid
,
1058 cifsInode
->cifsAttrs
= origattr
;
1066 * If dentry->d_inode is null (usually meaning the cached dentry
1067 * is a negative dentry) then we would attempt a standard SMB delete, but
1068 * if that fails we can not attempt the fall back mechanisms on EACCESS
1069 * but will return the EACCESS to the caller. Note that the VFS does not call
1070 * unlink on negative dentries currently.
1072 int cifs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1076 char *full_path
= NULL
;
1077 struct inode
*inode
= dentry
->d_inode
;
1078 struct cifsInodeInfo
*cifs_inode
;
1079 struct super_block
*sb
= dir
->i_sb
;
1080 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
1081 struct cifsTconInfo
*tcon
= cifs_sb
->tcon
;
1082 struct iattr
*attrs
= NULL
;
1083 __u32 dosattr
= 0, origattr
= 0;
1085 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir
, dentry
);
1089 /* Unlink can be called from rename so we can not take the
1090 * sb->s_vfs_rename_mutex here */
1091 full_path
= build_path_from_dentry(dentry
);
1092 if (full_path
== NULL
) {
1098 if ((tcon
->ses
->capabilities
& CAP_UNIX
) &&
1099 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1100 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1101 rc
= CIFSPOSIXDelFile(xid
, tcon
, full_path
,
1102 SMB_POSIX_UNLINK_FILE_TARGET
, cifs_sb
->local_nls
,
1103 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
1104 cFYI(1, "posix del rc %d", rc
);
1105 if ((rc
== 0) || (rc
== -ENOENT
))
1106 goto psx_del_no_retry
;
1110 rc
= CIFSSMBDelFile(xid
, tcon
, full_path
, cifs_sb
->local_nls
,
1111 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
1117 } else if (rc
== -ENOENT
) {
1119 } else if (rc
== -ETXTBSY
) {
1120 rc
= cifs_rename_pending_delete(full_path
, dentry
, xid
);
1123 } else if ((rc
== -EACCES
) && (dosattr
== 0) && inode
) {
1124 attrs
= kzalloc(sizeof(*attrs
), GFP_KERNEL
);
1125 if (attrs
== NULL
) {
1130 /* try to reset dos attributes */
1131 cifs_inode
= CIFS_I(inode
);
1132 origattr
= cifs_inode
->cifsAttrs
;
1134 origattr
|= ATTR_NORMAL
;
1135 dosattr
= origattr
& ~ATTR_READONLY
;
1137 dosattr
|= ATTR_NORMAL
;
1138 dosattr
|= ATTR_HIDDEN
;
1140 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
1144 goto retry_std_delete
;
1147 /* undo the setattr if we errored out and it's needed */
1148 if (rc
!= 0 && dosattr
!= 0)
1149 cifs_set_file_info(inode
, attrs
, xid
, full_path
, origattr
);
1153 cifs_inode
= CIFS_I(inode
);
1154 cifs_inode
->time
= 0; /* will force revalidate to get info
1156 inode
->i_ctime
= current_fs_time(sb
);
1158 dir
->i_ctime
= dir
->i_mtime
= current_fs_time(sb
);
1159 cifs_inode
= CIFS_I(dir
);
1160 CIFS_I(dir
)->time
= 0; /* force revalidate of dir as well */
1168 int cifs_mkdir(struct inode
*inode
, struct dentry
*direntry
, int mode
)
1172 struct cifs_sb_info
*cifs_sb
;
1173 struct cifsTconInfo
*pTcon
;
1174 char *full_path
= NULL
;
1175 struct inode
*newinode
= NULL
;
1176 struct cifs_fattr fattr
;
1178 cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode
, inode
);
1182 cifs_sb
= CIFS_SB(inode
->i_sb
);
1183 pTcon
= cifs_sb
->tcon
;
1185 full_path
= build_path_from_dentry(direntry
);
1186 if (full_path
== NULL
) {
1192 if ((pTcon
->ses
->capabilities
& CAP_UNIX
) &&
1193 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1194 le64_to_cpu(pTcon
->fsUnixInfo
.Capability
))) {
1196 FILE_UNIX_BASIC_INFO
*pInfo
=
1197 kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
1198 if (pInfo
== NULL
) {
1203 mode
&= ~current_umask();
1204 rc
= CIFSPOSIXCreate(xid
, pTcon
, SMB_O_DIRECTORY
| SMB_O_CREAT
,
1205 mode
, NULL
/* netfid */, pInfo
, &oplock
,
1206 full_path
, cifs_sb
->local_nls
,
1207 cifs_sb
->mnt_cifs_flags
&
1208 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1209 if (rc
== -EOPNOTSUPP
) {
1211 goto mkdir_retry_old
;
1213 cFYI(1, "posix mkdir returned 0x%x", rc
);
1216 if (pInfo
->Type
== cpu_to_le32(-1)) {
1217 /* no return info, go query for it */
1219 goto mkdir_get_info
;
1221 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1225 direntry
->d_op
= &cifs_ci_dentry_ops
;
1227 direntry
->d_op
= &cifs_dentry_ops
;
1229 cifs_unix_basic_to_fattr(&fattr
, pInfo
, cifs_sb
);
1230 cifs_fill_uniqueid(inode
->i_sb
, &fattr
);
1231 newinode
= cifs_iget(inode
->i_sb
, &fattr
);
1234 goto mkdir_get_info
;
1237 d_instantiate(direntry
, newinode
);
1239 #ifdef CONFIG_CIFS_DEBUG2
1240 cFYI(1, "instantiated dentry %p %s to inode %p",
1241 direntry
, direntry
->d_name
.name
, newinode
);
1243 if (newinode
->i_nlink
!= 2)
1244 cFYI(1, "unexpected number of links %d",
1252 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1253 rc
= CIFSSMBMkDir(xid
, pTcon
, full_path
, cifs_sb
->local_nls
,
1254 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
1256 cFYI(1, "cifs_mkdir returned 0x%x", rc
);
1261 if (pTcon
->unix_ext
)
1262 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
1265 rc
= cifs_get_inode_info(&newinode
, full_path
, NULL
,
1266 inode
->i_sb
, xid
, NULL
);
1269 direntry
->d_op
= &cifs_ci_dentry_ops
;
1271 direntry
->d_op
= &cifs_dentry_ops
;
1272 d_instantiate(direntry
, newinode
);
1273 /* setting nlink not necessary except in cases where we
1274 * failed to get it from the server or was set bogus */
1275 if ((direntry
->d_inode
) && (direntry
->d_inode
->i_nlink
< 2))
1276 direntry
->d_inode
->i_nlink
= 2;
1278 mode
&= ~current_umask();
1279 /* must turn on setgid bit if parent dir has it */
1280 if (inode
->i_mode
& S_ISGID
)
1283 if (pTcon
->unix_ext
) {
1284 struct cifs_unix_set_info_args args
= {
1286 .ctime
= NO_CHANGE_64
,
1287 .atime
= NO_CHANGE_64
,
1288 .mtime
= NO_CHANGE_64
,
1291 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1292 args
.uid
= (__u64
)current_fsuid();
1293 if (inode
->i_mode
& S_ISGID
)
1294 args
.gid
= (__u64
)inode
->i_gid
;
1296 args
.gid
= (__u64
)current_fsgid();
1298 args
.uid
= NO_CHANGE_64
;
1299 args
.gid
= NO_CHANGE_64
;
1301 CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, &args
,
1303 cifs_sb
->mnt_cifs_flags
&
1304 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1306 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
1307 (mode
& S_IWUGO
) == 0) {
1308 FILE_BASIC_INFO pInfo
;
1309 struct cifsInodeInfo
*cifsInode
;
1312 memset(&pInfo
, 0, sizeof(pInfo
));
1313 cifsInode
= CIFS_I(newinode
);
1314 dosattrs
= cifsInode
->cifsAttrs
|ATTR_READONLY
;
1315 pInfo
.Attributes
= cpu_to_le32(dosattrs
);
1316 tmprc
= CIFSSMBSetPathInfo(xid
, pTcon
,
1319 cifs_sb
->mnt_cifs_flags
&
1320 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1322 cifsInode
->cifsAttrs
= dosattrs
;
1324 if (direntry
->d_inode
) {
1325 if (cifs_sb
->mnt_cifs_flags
&
1327 direntry
->d_inode
->i_mode
=
1330 if (cifs_sb
->mnt_cifs_flags
&
1331 CIFS_MOUNT_SET_UID
) {
1332 direntry
->d_inode
->i_uid
=
1334 if (inode
->i_mode
& S_ISGID
)
1335 direntry
->d_inode
->i_gid
=
1338 direntry
->d_inode
->i_gid
=
1350 int cifs_rmdir(struct inode
*inode
, struct dentry
*direntry
)
1354 struct cifs_sb_info
*cifs_sb
;
1355 struct cifsTconInfo
*pTcon
;
1356 char *full_path
= NULL
;
1357 struct cifsInodeInfo
*cifsInode
;
1359 cFYI(1, "cifs_rmdir, inode = 0x%p", inode
);
1363 cifs_sb
= CIFS_SB(inode
->i_sb
);
1364 pTcon
= cifs_sb
->tcon
;
1366 full_path
= build_path_from_dentry(direntry
);
1367 if (full_path
== NULL
) {
1373 rc
= CIFSSMBRmDir(xid
, pTcon
, full_path
, cifs_sb
->local_nls
,
1374 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
1378 spin_lock(&direntry
->d_inode
->i_lock
);
1379 i_size_write(direntry
->d_inode
, 0);
1380 clear_nlink(direntry
->d_inode
);
1381 spin_unlock(&direntry
->d_inode
->i_lock
);
1384 cifsInode
= CIFS_I(direntry
->d_inode
);
1385 cifsInode
->time
= 0; /* force revalidate to go get info when
1388 cifsInode
= CIFS_I(inode
);
1389 cifsInode
->time
= 0; /* force revalidate to get parent dir info
1390 since cached search results now invalid */
1392 direntry
->d_inode
->i_ctime
= inode
->i_ctime
= inode
->i_mtime
=
1393 current_fs_time(inode
->i_sb
);
1401 cifs_do_rename(int xid
, struct dentry
*from_dentry
, const char *fromPath
,
1402 struct dentry
*to_dentry
, const char *toPath
)
1404 struct cifs_sb_info
*cifs_sb
= CIFS_SB(from_dentry
->d_sb
);
1405 struct cifsTconInfo
*pTcon
= cifs_sb
->tcon
;
1409 /* try path-based rename first */
1410 rc
= CIFSSMBRename(xid
, pTcon
, fromPath
, toPath
, cifs_sb
->local_nls
,
1411 cifs_sb
->mnt_cifs_flags
&
1412 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1415 * don't bother with rename by filehandle unless file is busy and
1416 * source Note that cross directory moves do not work with
1417 * rename by filehandle to various Windows servers.
1419 if (rc
== 0 || rc
!= -ETXTBSY
)
1422 /* open-file renames don't work across directories */
1423 if (to_dentry
->d_parent
!= from_dentry
->d_parent
)
1426 /* open the file to be renamed -- we need DELETE perms */
1427 rc
= CIFSSMBOpen(xid
, pTcon
, fromPath
, FILE_OPEN
, DELETE
,
1428 CREATE_NOT_DIR
, &srcfid
, &oplock
, NULL
,
1429 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1430 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1433 rc
= CIFSSMBRenameOpenFile(xid
, pTcon
, srcfid
,
1434 (const char *) to_dentry
->d_name
.name
,
1435 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1436 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1438 CIFSSMBClose(xid
, pTcon
, srcfid
);
1444 int cifs_rename(struct inode
*source_dir
, struct dentry
*source_dentry
,
1445 struct inode
*target_dir
, struct dentry
*target_dentry
)
1447 char *fromName
= NULL
;
1448 char *toName
= NULL
;
1449 struct cifs_sb_info
*cifs_sb
;
1450 struct cifsTconInfo
*tcon
;
1451 FILE_UNIX_BASIC_INFO
*info_buf_source
= NULL
;
1452 FILE_UNIX_BASIC_INFO
*info_buf_target
;
1455 cifs_sb
= CIFS_SB(source_dir
->i_sb
);
1456 tcon
= cifs_sb
->tcon
;
1461 * we already have the rename sem so we do not need to
1462 * grab it again here to protect the path integrity
1464 fromName
= build_path_from_dentry(source_dentry
);
1465 if (fromName
== NULL
) {
1467 goto cifs_rename_exit
;
1470 toName
= build_path_from_dentry(target_dentry
);
1471 if (toName
== NULL
) {
1473 goto cifs_rename_exit
;
1476 rc
= cifs_do_rename(xid
, source_dentry
, fromName
,
1477 target_dentry
, toName
);
1479 if (rc
== -EEXIST
&& tcon
->unix_ext
) {
1481 * Are src and dst hardlinks of same inode? We can
1482 * only tell with unix extensions enabled
1485 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO
),
1487 if (info_buf_source
== NULL
) {
1489 goto cifs_rename_exit
;
1492 info_buf_target
= info_buf_source
+ 1;
1493 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, fromName
,
1496 cifs_sb
->mnt_cifs_flags
&
1497 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1501 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, toName
,
1504 cifs_sb
->mnt_cifs_flags
&
1505 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1507 if (tmprc
== 0 && (info_buf_source
->UniqueId
==
1508 info_buf_target
->UniqueId
)) {
1509 /* same file, POSIX says that this is a noop */
1511 goto cifs_rename_exit
;
1513 } /* else ... BB we could add the same check for Windows by
1514 checking the UniqueId via FILE_INTERNAL_INFO */
1517 /* Try unlinking the target dentry if it's not negative */
1518 if (target_dentry
->d_inode
&& (rc
== -EACCES
|| rc
== -EEXIST
)) {
1519 tmprc
= cifs_unlink(target_dir
, target_dentry
);
1521 goto cifs_rename_exit
;
1523 rc
= cifs_do_rename(xid
, source_dentry
, fromName
,
1524 target_dentry
, toName
);
1528 kfree(info_buf_source
);
1536 cifs_inode_needs_reval(struct inode
*inode
)
1538 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
1540 if (cifs_i
->clientCanCacheRead
)
1543 if (!lookupCacheEnabled
)
1546 if (cifs_i
->time
== 0)
1549 if (time_after_eq(jiffies
, cifs_i
->time
+ HZ
))
1552 /* hardlinked files w/ noserverino get "special" treatment */
1553 if (!(CIFS_SB(inode
->i_sb
)->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) &&
1554 S_ISREG(inode
->i_mode
) && inode
->i_nlink
!= 1)
1560 /* check invalid_mapping flag and zap the cache if it's set */
1562 cifs_invalidate_mapping(struct inode
*inode
)
1565 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
1567 cifs_i
->invalid_mapping
= false;
1569 /* write back any cached data */
1570 if (inode
->i_mapping
&& inode
->i_mapping
->nrpages
!= 0) {
1571 rc
= filemap_write_and_wait(inode
->i_mapping
);
1573 cifs_i
->write_behind_rc
= rc
;
1575 invalidate_remote_inode(inode
);
1576 cifs_fscache_reset_inode_cookie(inode
);
1579 int cifs_revalidate_file(struct file
*filp
)
1582 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
1584 if (!cifs_inode_needs_reval(inode
))
1587 if (CIFS_SB(inode
->i_sb
)->tcon
->unix_ext
)
1588 rc
= cifs_get_file_info_unix(filp
);
1590 rc
= cifs_get_file_info(filp
);
1593 if (CIFS_I(inode
)->invalid_mapping
)
1594 cifs_invalidate_mapping(inode
);
1599 /* revalidate a dentry's inode attributes */
1600 int cifs_revalidate_dentry(struct dentry
*dentry
)
1604 char *full_path
= NULL
;
1605 struct inode
*inode
= dentry
->d_inode
;
1606 struct super_block
*sb
= dentry
->d_sb
;
1613 if (!cifs_inode_needs_reval(inode
))
1616 /* can not safely grab the rename sem here if rename calls revalidate
1617 since that would deadlock */
1618 full_path
= build_path_from_dentry(dentry
);
1619 if (full_path
== NULL
) {
1624 cFYI(1, "Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1625 "jiffies %ld", full_path
, inode
, inode
->i_count
.counter
,
1626 dentry
, dentry
->d_time
, jiffies
);
1628 if (CIFS_SB(sb
)->tcon
->unix_ext
)
1629 rc
= cifs_get_inode_info_unix(&inode
, full_path
, sb
, xid
);
1631 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, sb
,
1635 if (CIFS_I(inode
)->invalid_mapping
)
1636 cifs_invalidate_mapping(inode
);
1643 int cifs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
1646 int err
= cifs_revalidate_dentry(dentry
);
1648 generic_fillattr(dentry
->d_inode
, stat
);
1649 stat
->blksize
= CIFS_MAX_MSGSIZE
;
1650 stat
->ino
= CIFS_I(dentry
->d_inode
)->uniqueid
;
1655 static int cifs_truncate_page(struct address_space
*mapping
, loff_t from
)
1657 pgoff_t index
= from
>> PAGE_CACHE_SHIFT
;
1658 unsigned offset
= from
& (PAGE_CACHE_SIZE
- 1);
1662 page
= grab_cache_page(mapping
, index
);
1666 zero_user_segment(page
, offset
, PAGE_CACHE_SIZE
);
1668 page_cache_release(page
);
1672 static void cifs_setsize(struct inode
*inode
, loff_t offset
)
1676 spin_lock(&inode
->i_lock
);
1677 oldsize
= inode
->i_size
;
1678 i_size_write(inode
, offset
);
1679 spin_unlock(&inode
->i_lock
);
1681 truncate_pagecache(inode
, oldsize
, offset
);
1685 cifs_set_file_size(struct inode
*inode
, struct iattr
*attrs
,
1686 int xid
, char *full_path
)
1689 struct cifsFileInfo
*open_file
;
1690 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1691 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1692 struct cifsTconInfo
*pTcon
= cifs_sb
->tcon
;
1695 * To avoid spurious oplock breaks from server, in the case of
1696 * inodes that we already have open, avoid doing path based
1697 * setting of file size if we can do it by handle.
1698 * This keeps our caching token (oplock) and avoids timeouts
1699 * when the local oplock break takes longer to flush
1700 * writebehind data than the SMB timeout for the SetPathInfo
1701 * request would allow
1703 open_file
= find_writable_file(cifsInode
);
1705 __u16 nfid
= open_file
->netfid
;
1706 __u32 npid
= open_file
->pid
;
1707 rc
= CIFSSMBSetFileSize(xid
, pTcon
, attrs
->ia_size
, nfid
,
1709 cifsFileInfo_put(open_file
);
1710 cFYI(1, "SetFSize for attrs rc = %d", rc
);
1711 if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
1712 unsigned int bytes_written
;
1713 rc
= CIFSSMBWrite(xid
, pTcon
, nfid
, 0, attrs
->ia_size
,
1714 &bytes_written
, NULL
, NULL
, 1);
1715 cFYI(1, "Wrt seteof rc %d", rc
);
1721 /* Set file size by pathname rather than by handle
1722 either because no valid, writeable file handle for
1723 it was found or because there was an error setting
1725 rc
= CIFSSMBSetEOF(xid
, pTcon
, full_path
, attrs
->ia_size
,
1726 false, cifs_sb
->local_nls
,
1727 cifs_sb
->mnt_cifs_flags
&
1728 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1729 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc
);
1730 if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
1734 rc
= SMBLegacyOpen(xid
, pTcon
, full_path
,
1735 FILE_OPEN
, GENERIC_WRITE
,
1736 CREATE_NOT_DIR
, &netfid
, &oplock
, NULL
,
1738 cifs_sb
->mnt_cifs_flags
&
1739 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1741 unsigned int bytes_written
;
1742 rc
= CIFSSMBWrite(xid
, pTcon
, netfid
, 0,
1744 &bytes_written
, NULL
,
1746 cFYI(1, "wrt seteof rc %d", rc
);
1747 CIFSSMBClose(xid
, pTcon
, netfid
);
1753 cifsInode
->server_eof
= attrs
->ia_size
;
1754 cifs_setsize(inode
, attrs
->ia_size
);
1755 cifs_truncate_page(inode
->i_mapping
, inode
->i_size
);
1762 cifs_setattr_unix(struct dentry
*direntry
, struct iattr
*attrs
)
1766 char *full_path
= NULL
;
1767 struct inode
*inode
= direntry
->d_inode
;
1768 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1769 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1770 struct cifsTconInfo
*pTcon
= cifs_sb
->tcon
;
1771 struct cifs_unix_set_info_args
*args
= NULL
;
1772 struct cifsFileInfo
*open_file
;
1774 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1775 direntry
->d_name
.name
, attrs
->ia_valid
);
1779 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
1780 attrs
->ia_valid
|= ATTR_FORCE
;
1782 rc
= inode_change_ok(inode
, attrs
);
1786 full_path
= build_path_from_dentry(direntry
);
1787 if (full_path
== NULL
) {
1793 * Attempt to flush data before changing attributes. We need to do
1794 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1795 * ownership or mode then we may also need to do this. Here, we take
1796 * the safe way out and just do the flush on all setattr requests. If
1797 * the flush returns error, store it to report later and continue.
1799 * BB: This should be smarter. Why bother flushing pages that
1800 * will be truncated anyway? Also, should we error out here if
1801 * the flush returns error?
1803 rc
= filemap_write_and_wait(inode
->i_mapping
);
1805 cifsInode
->write_behind_rc
= rc
;
1809 if (attrs
->ia_valid
& ATTR_SIZE
) {
1810 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
1815 /* skip mode change if it's just for clearing setuid/setgid */
1816 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
1817 attrs
->ia_valid
&= ~ATTR_MODE
;
1819 args
= kmalloc(sizeof(*args
), GFP_KERNEL
);
1825 /* set up the struct */
1826 if (attrs
->ia_valid
& ATTR_MODE
)
1827 args
->mode
= attrs
->ia_mode
;
1829 args
->mode
= NO_CHANGE_64
;
1831 if (attrs
->ia_valid
& ATTR_UID
)
1832 args
->uid
= attrs
->ia_uid
;
1834 args
->uid
= NO_CHANGE_64
;
1836 if (attrs
->ia_valid
& ATTR_GID
)
1837 args
->gid
= attrs
->ia_gid
;
1839 args
->gid
= NO_CHANGE_64
;
1841 if (attrs
->ia_valid
& ATTR_ATIME
)
1842 args
->atime
= cifs_UnixTimeToNT(attrs
->ia_atime
);
1844 args
->atime
= NO_CHANGE_64
;
1846 if (attrs
->ia_valid
& ATTR_MTIME
)
1847 args
->mtime
= cifs_UnixTimeToNT(attrs
->ia_mtime
);
1849 args
->mtime
= NO_CHANGE_64
;
1851 if (attrs
->ia_valid
& ATTR_CTIME
)
1852 args
->ctime
= cifs_UnixTimeToNT(attrs
->ia_ctime
);
1854 args
->ctime
= NO_CHANGE_64
;
1857 open_file
= find_writable_file(cifsInode
);
1859 u16 nfid
= open_file
->netfid
;
1860 u32 npid
= open_file
->pid
;
1861 rc
= CIFSSMBUnixSetFileInfo(xid
, pTcon
, args
, nfid
, npid
);
1862 cifsFileInfo_put(open_file
);
1864 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, args
,
1866 cifs_sb
->mnt_cifs_flags
&
1867 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1873 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
1874 attrs
->ia_size
!= i_size_read(inode
))
1875 truncate_setsize(inode
, attrs
->ia_size
);
1877 setattr_copy(inode
, attrs
);
1878 mark_inode_dirty(inode
);
1880 /* force revalidate when any of these times are set since some
1881 of the fs types (eg ext3, fat) do not have fine enough
1882 time granularity to match protocol, and we do not have a
1883 a way (yet) to query the server fs's time granularity (and
1884 whether it rounds times down).
1886 if (attrs
->ia_valid
& (ATTR_MTIME
| ATTR_CTIME
))
1887 cifsInode
->time
= 0;
1896 cifs_setattr_nounix(struct dentry
*direntry
, struct iattr
*attrs
)
1899 struct inode
*inode
= direntry
->d_inode
;
1900 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1901 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1902 char *full_path
= NULL
;
1905 __u64 mode
= NO_CHANGE_64
;
1909 cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
1910 direntry
->d_name
.name
, attrs
->ia_valid
);
1912 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
1913 attrs
->ia_valid
|= ATTR_FORCE
;
1915 rc
= inode_change_ok(inode
, attrs
);
1921 full_path
= build_path_from_dentry(direntry
);
1922 if (full_path
== NULL
) {
1929 * Attempt to flush data before changing attributes. We need to do
1930 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1931 * ownership or mode then we may also need to do this. Here, we take
1932 * the safe way out and just do the flush on all setattr requests. If
1933 * the flush returns error, store it to report later and continue.
1935 * BB: This should be smarter. Why bother flushing pages that
1936 * will be truncated anyway? Also, should we error out here if
1937 * the flush returns error?
1939 rc
= filemap_write_and_wait(inode
->i_mapping
);
1941 cifsInode
->write_behind_rc
= rc
;
1945 if (attrs
->ia_valid
& ATTR_SIZE
) {
1946 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
1948 goto cifs_setattr_exit
;
1952 * Without unix extensions we can't send ownership changes to the
1953 * server, so silently ignore them. This is consistent with how
1954 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
1955 * CIFSACL support + proper Windows to Unix idmapping, we may be
1956 * able to support this in the future.
1958 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
))
1959 attrs
->ia_valid
&= ~(ATTR_UID
| ATTR_GID
);
1961 /* skip mode change if it's just for clearing setuid/setgid */
1962 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
1963 attrs
->ia_valid
&= ~ATTR_MODE
;
1965 if (attrs
->ia_valid
& ATTR_MODE
) {
1966 cFYI(1, "Mode changed to 0%o", attrs
->ia_mode
);
1967 mode
= attrs
->ia_mode
;
1970 if (attrs
->ia_valid
& ATTR_MODE
) {
1972 #ifdef CONFIG_CIFS_EXPERIMENTAL
1973 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
)
1974 rc
= mode_to_acl(inode
, full_path
, mode
);
1977 if (((mode
& S_IWUGO
) == 0) &&
1978 (cifsInode
->cifsAttrs
& ATTR_READONLY
) == 0) {
1980 dosattr
= cifsInode
->cifsAttrs
| ATTR_READONLY
;
1982 /* fix up mode if we're not using dynperm */
1983 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
) == 0)
1984 attrs
->ia_mode
= inode
->i_mode
& ~S_IWUGO
;
1985 } else if ((mode
& S_IWUGO
) &&
1986 (cifsInode
->cifsAttrs
& ATTR_READONLY
)) {
1988 dosattr
= cifsInode
->cifsAttrs
& ~ATTR_READONLY
;
1989 /* Attributes of 0 are ignored */
1991 dosattr
|= ATTR_NORMAL
;
1993 /* reset local inode permissions to normal */
1994 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
1995 attrs
->ia_mode
&= ~(S_IALLUGO
);
1996 if (S_ISDIR(inode
->i_mode
))
1998 cifs_sb
->mnt_dir_mode
;
2001 cifs_sb
->mnt_file_mode
;
2003 } else if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2004 /* ignore mode change - ATTR_READONLY hasn't changed */
2005 attrs
->ia_valid
&= ~ATTR_MODE
;
2009 if (attrs
->ia_valid
& (ATTR_MTIME
|ATTR_ATIME
|ATTR_CTIME
) ||
2010 ((attrs
->ia_valid
& ATTR_MODE
) && dosattr
)) {
2011 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
2012 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2014 /* Even if error on time set, no sense failing the call if
2015 the server would set the time to a reasonable value anyway,
2016 and this check ensures that we are not being called from
2017 sys_utimes in which case we ought to fail the call back to
2018 the user when the server rejects the call */
2019 if ((rc
) && (attrs
->ia_valid
&
2020 (ATTR_MODE
| ATTR_GID
| ATTR_UID
| ATTR_SIZE
)))
2024 /* do not need local check to inode_check_ok since the server does
2027 goto cifs_setattr_exit
;
2029 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
2030 attrs
->ia_size
!= i_size_read(inode
))
2031 truncate_setsize(inode
, attrs
->ia_size
);
2033 setattr_copy(inode
, attrs
);
2034 mark_inode_dirty(inode
);
2044 cifs_setattr(struct dentry
*direntry
, struct iattr
*attrs
)
2046 struct inode
*inode
= direntry
->d_inode
;
2047 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2048 struct cifsTconInfo
*pTcon
= cifs_sb
->tcon
;
2050 if (pTcon
->unix_ext
)
2051 return cifs_setattr_unix(direntry
, attrs
);
2053 return cifs_setattr_nounix(direntry
, attrs
);
2055 /* BB: add cifs_setattr_legacy for really old servers */