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"
34 static void cifs_set_ops(struct inode
*inode
, const bool is_dfs_referral
)
36 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
38 switch (inode
->i_mode
& S_IFMT
) {
40 inode
->i_op
= &cifs_file_inode_ops
;
41 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
42 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
43 inode
->i_fop
= &cifs_file_direct_nobrl_ops
;
45 inode
->i_fop
= &cifs_file_direct_ops
;
46 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
47 inode
->i_fop
= &cifs_file_nobrl_ops
;
48 else { /* not direct, send byte range locks */
49 inode
->i_fop
= &cifs_file_ops
;
53 /* check if server can support readpages */
54 if (cifs_sb
->tcon
->ses
->server
->maxBuf
<
55 PAGE_CACHE_SIZE
+ MAX_CIFS_HDR_SIZE
)
56 inode
->i_data
.a_ops
= &cifs_addr_ops_smallbuf
;
58 inode
->i_data
.a_ops
= &cifs_addr_ops
;
61 #ifdef CONFIG_CIFS_DFS_UPCALL
62 if (is_dfs_referral
) {
63 inode
->i_op
= &cifs_dfs_referral_inode_operations
;
65 #else /* NO DFS support, treat as a directory */
68 inode
->i_op
= &cifs_dir_inode_ops
;
69 inode
->i_fop
= &cifs_dir_ops
;
73 inode
->i_op
= &cifs_symlink_inode_ops
;
76 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
81 /* check inode attributes against fattr. If they don't match, tag the
82 * inode for cache invalidation
85 cifs_revalidate_cache(struct inode
*inode
, struct cifs_fattr
*fattr
)
87 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
89 cFYI(1, "%s: revalidating inode %llu", __func__
, cifs_i
->uniqueid
);
91 if (inode
->i_state
& I_NEW
) {
92 cFYI(1, "%s: inode %llu is new", __func__
, cifs_i
->uniqueid
);
96 /* don't bother with revalidation if we have an oplock */
97 if (cifs_i
->clientCanCacheRead
) {
98 cFYI(1, "%s: inode %llu is oplocked", __func__
,
103 /* revalidate if mtime or size have changed */
104 if (timespec_equal(&inode
->i_mtime
, &fattr
->cf_mtime
) &&
105 cifs_i
->server_eof
== fattr
->cf_eof
) {
106 cFYI(1, "%s: inode %llu is unchanged", __func__
,
111 cFYI(1, "%s: invalidating inode %llu mapping", __func__
,
113 cifs_i
->invalid_mapping
= true;
116 /* populate an inode with info from a cifs_fattr struct */
118 cifs_fattr_to_inode(struct inode
*inode
, struct cifs_fattr
*fattr
)
120 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
121 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
122 unsigned long oldtime
= cifs_i
->time
;
124 cifs_revalidate_cache(inode
, fattr
);
126 inode
->i_atime
= fattr
->cf_atime
;
127 inode
->i_mtime
= fattr
->cf_mtime
;
128 inode
->i_ctime
= fattr
->cf_ctime
;
129 inode
->i_rdev
= fattr
->cf_rdev
;
130 inode
->i_nlink
= fattr
->cf_nlink
;
131 inode
->i_uid
= fattr
->cf_uid
;
132 inode
->i_gid
= fattr
->cf_gid
;
134 /* if dynperm is set, don't clobber existing mode */
135 if (inode
->i_state
& I_NEW
||
136 !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
))
137 inode
->i_mode
= fattr
->cf_mode
;
139 cifs_i
->cifsAttrs
= fattr
->cf_cifsattrs
;
141 if (fattr
->cf_flags
& CIFS_FATTR_NEED_REVAL
)
144 cifs_i
->time
= jiffies
;
146 cFYI(1, "inode 0x%p old_time=%ld new_time=%ld", inode
,
147 oldtime
, cifs_i
->time
);
149 cifs_i
->delete_pending
= fattr
->cf_flags
& CIFS_FATTR_DELETE_PENDING
;
151 cifs_i
->server_eof
= fattr
->cf_eof
;
153 * Can't safely change the file size here if the client is writing to
154 * it due to potential races.
156 spin_lock(&inode
->i_lock
);
157 if (is_size_safe_to_change(cifs_i
, fattr
->cf_eof
)) {
158 i_size_write(inode
, fattr
->cf_eof
);
161 * i_blocks is not related to (i_size / i_blksize),
162 * but instead 512 byte (2**9) size is required for
163 * calculating num blocks.
165 inode
->i_blocks
= (512 - 1 + fattr
->cf_bytes
) >> 9;
167 spin_unlock(&inode
->i_lock
);
169 cifs_set_ops(inode
, fattr
->cf_flags
& CIFS_FATTR_DFS_REFERRAL
);
173 cifs_fill_uniqueid(struct super_block
*sb
, struct cifs_fattr
*fattr
)
175 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
177 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)
180 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
183 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
185 cifs_unix_basic_to_fattr(struct cifs_fattr
*fattr
, FILE_UNIX_BASIC_INFO
*info
,
186 struct cifs_sb_info
*cifs_sb
)
188 memset(fattr
, 0, sizeof(*fattr
));
189 fattr
->cf_uniqueid
= le64_to_cpu(info
->UniqueId
);
190 fattr
->cf_bytes
= le64_to_cpu(info
->NumOfBytes
);
191 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
193 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
194 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastModificationTime
);
195 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->LastStatusChange
);
196 fattr
->cf_mode
= le64_to_cpu(info
->Permissions
);
199 * Since we set the inode type below we need to mask off
200 * to avoid strange results if bits set above.
202 fattr
->cf_mode
&= ~S_IFMT
;
203 switch (le32_to_cpu(info
->Type
)) {
205 fattr
->cf_mode
|= S_IFREG
;
206 fattr
->cf_dtype
= DT_REG
;
209 fattr
->cf_mode
|= S_IFLNK
;
210 fattr
->cf_dtype
= DT_LNK
;
213 fattr
->cf_mode
|= S_IFDIR
;
214 fattr
->cf_dtype
= DT_DIR
;
217 fattr
->cf_mode
|= S_IFCHR
;
218 fattr
->cf_dtype
= DT_CHR
;
219 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
220 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
223 fattr
->cf_mode
|= S_IFBLK
;
224 fattr
->cf_dtype
= DT_BLK
;
225 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
226 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
229 fattr
->cf_mode
|= S_IFIFO
;
230 fattr
->cf_dtype
= DT_FIFO
;
233 fattr
->cf_mode
|= S_IFSOCK
;
234 fattr
->cf_dtype
= DT_SOCK
;
237 /* safest to call it a file if we do not know */
238 fattr
->cf_mode
|= S_IFREG
;
239 fattr
->cf_dtype
= DT_REG
;
240 cFYI(1, "unknown type %d", le32_to_cpu(info
->Type
));
244 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
)
245 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
247 fattr
->cf_uid
= le64_to_cpu(info
->Uid
);
249 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
)
250 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
252 fattr
->cf_gid
= le64_to_cpu(info
->Gid
);
254 fattr
->cf_nlink
= le64_to_cpu(info
->Nlinks
);
258 * Fill a cifs_fattr struct with fake inode info.
260 * Needed to setup cifs_fattr data for the directory which is the
261 * junction to the new submount (ie to setup the fake directory
262 * which represents a DFS referral).
265 cifs_create_dfs_fattr(struct cifs_fattr
*fattr
, struct super_block
*sb
)
267 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
269 cFYI(1, "creating fake fattr for DFS referral");
271 memset(fattr
, 0, sizeof(*fattr
));
272 fattr
->cf_mode
= S_IFDIR
| S_IXUGO
| S_IRWXU
;
273 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
274 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
275 fattr
->cf_atime
= CURRENT_TIME
;
276 fattr
->cf_ctime
= CURRENT_TIME
;
277 fattr
->cf_mtime
= CURRENT_TIME
;
279 fattr
->cf_flags
|= CIFS_FATTR_DFS_REFERRAL
;
282 int cifs_get_file_info_unix(struct file
*filp
)
286 FILE_UNIX_BASIC_INFO find_data
;
287 struct cifs_fattr fattr
;
288 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
289 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
290 struct cifsTconInfo
*tcon
= cifs_sb
->tcon
;
291 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*) filp
->private_data
;
294 rc
= CIFSSMBUnixQFileInfo(xid
, tcon
, cfile
->netfid
, &find_data
);
296 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
297 } else if (rc
== -EREMOTE
) {
298 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
302 cifs_fattr_to_inode(inode
, &fattr
);
307 int cifs_get_inode_info_unix(struct inode
**pinode
,
308 const unsigned char *full_path
,
309 struct super_block
*sb
, int xid
)
312 FILE_UNIX_BASIC_INFO find_data
;
313 struct cifs_fattr fattr
;
314 struct cifsTconInfo
*tcon
;
315 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
317 tcon
= cifs_sb
->tcon
;
318 cFYI(1, "Getting info on %s", full_path
);
320 /* could have done a find first instead but this returns more info */
321 rc
= CIFSSMBUnixQPathInfo(xid
, tcon
, full_path
, &find_data
,
322 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
323 CIFS_MOUNT_MAP_SPECIAL_CHR
);
326 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
327 } else if (rc
== -EREMOTE
) {
328 cifs_create_dfs_fattr(&fattr
, sb
);
334 if (*pinode
== NULL
) {
336 cifs_fill_uniqueid(sb
, &fattr
);
337 *pinode
= cifs_iget(sb
, &fattr
);
341 /* we already have inode, update it */
342 cifs_fattr_to_inode(*pinode
, &fattr
);
349 cifs_sfu_type(struct cifs_fattr
*fattr
, const unsigned char *path
,
350 struct cifs_sb_info
*cifs_sb
, int xid
)
355 struct cifsTconInfo
*pTcon
= cifs_sb
->tcon
;
357 unsigned int bytes_read
;
362 fattr
->cf_mode
&= ~S_IFMT
;
364 if (fattr
->cf_eof
== 0) {
365 fattr
->cf_mode
|= S_IFIFO
;
366 fattr
->cf_dtype
= DT_FIFO
;
368 } else if (fattr
->cf_eof
< 8) {
369 fattr
->cf_mode
|= S_IFREG
;
370 fattr
->cf_dtype
= DT_REG
;
371 return -EINVAL
; /* EOPNOTSUPP? */
374 rc
= CIFSSMBOpen(xid
, pTcon
, path
, FILE_OPEN
, GENERIC_READ
,
375 CREATE_NOT_DIR
, &netfid
, &oplock
, NULL
,
377 cifs_sb
->mnt_cifs_flags
&
378 CIFS_MOUNT_MAP_SPECIAL_CHR
);
380 int buf_type
= CIFS_NO_BUFFER
;
382 rc
= CIFSSMBRead(xid
, pTcon
, netfid
,
383 24 /* length */, 0 /* offset */,
384 &bytes_read
, &pbuf
, &buf_type
);
385 if ((rc
== 0) && (bytes_read
>= 8)) {
386 if (memcmp("IntxBLK", pbuf
, 8) == 0) {
387 cFYI(1, "Block device");
388 fattr
->cf_mode
|= S_IFBLK
;
389 fattr
->cf_dtype
= DT_BLK
;
390 if (bytes_read
== 24) {
391 /* we have enough to decode dev num */
392 __u64 mjr
; /* major */
393 __u64 mnr
; /* minor */
394 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
395 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
396 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
398 } else if (memcmp("IntxCHR", pbuf
, 8) == 0) {
399 cFYI(1, "Char device");
400 fattr
->cf_mode
|= S_IFCHR
;
401 fattr
->cf_dtype
= DT_CHR
;
402 if (bytes_read
== 24) {
403 /* we have enough to decode dev num */
404 __u64 mjr
; /* major */
405 __u64 mnr
; /* minor */
406 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
407 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
408 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
410 } else if (memcmp("IntxLNK", pbuf
, 7) == 0) {
412 fattr
->cf_mode
|= S_IFLNK
;
413 fattr
->cf_dtype
= DT_LNK
;
415 fattr
->cf_mode
|= S_IFREG
; /* file? */
416 fattr
->cf_dtype
= DT_REG
;
420 fattr
->cf_mode
|= S_IFREG
; /* then it is a file */
421 fattr
->cf_dtype
= DT_REG
;
422 rc
= -EOPNOTSUPP
; /* or some unknown SFU type */
424 CIFSSMBClose(xid
, pTcon
, netfid
);
429 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
432 * Fetch mode bits as provided by SFU.
434 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
436 static int cifs_sfu_mode(struct cifs_fattr
*fattr
, const unsigned char *path
,
437 struct cifs_sb_info
*cifs_sb
, int xid
)
439 #ifdef CONFIG_CIFS_XATTR
444 rc
= CIFSSMBQAllEAs(xid
, cifs_sb
->tcon
, path
, "SETFILEBITS",
445 ea_value
, 4 /* size of buf */, cifs_sb
->local_nls
,
446 cifs_sb
->mnt_cifs_flags
&
447 CIFS_MOUNT_MAP_SPECIAL_CHR
);
451 mode
= le32_to_cpu(*((__le32
*)ea_value
));
452 fattr
->cf_mode
&= ~SFBITS_MASK
;
453 cFYI(1, "special bits 0%o org mode 0%o", mode
,
455 fattr
->cf_mode
= (mode
& SFBITS_MASK
) | fattr
->cf_mode
;
456 cFYI(1, "special mode bits 0%o", mode
);
465 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
467 cifs_all_info_to_fattr(struct cifs_fattr
*fattr
, FILE_ALL_INFO
*info
,
468 struct cifs_sb_info
*cifs_sb
, bool adjust_tz
)
470 memset(fattr
, 0, sizeof(*fattr
));
471 fattr
->cf_cifsattrs
= le32_to_cpu(info
->Attributes
);
472 if (info
->DeletePending
)
473 fattr
->cf_flags
|= CIFS_FATTR_DELETE_PENDING
;
475 if (info
->LastAccessTime
)
476 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
478 fattr
->cf_atime
= CURRENT_TIME
;
480 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->ChangeTime
);
481 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastWriteTime
);
484 fattr
->cf_ctime
.tv_sec
+= cifs_sb
->tcon
->ses
->server
->timeAdj
;
485 fattr
->cf_mtime
.tv_sec
+= cifs_sb
->tcon
->ses
->server
->timeAdj
;
488 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
489 fattr
->cf_bytes
= le64_to_cpu(info
->AllocationSize
);
491 if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
) {
492 fattr
->cf_mode
= S_IFDIR
| cifs_sb
->mnt_dir_mode
;
493 fattr
->cf_dtype
= DT_DIR
;
495 fattr
->cf_mode
= S_IFREG
| cifs_sb
->mnt_file_mode
;
496 fattr
->cf_dtype
= DT_REG
;
498 /* clear write bits if ATTR_READONLY is set */
499 if (fattr
->cf_cifsattrs
& ATTR_READONLY
)
500 fattr
->cf_mode
&= ~(S_IWUGO
);
503 fattr
->cf_nlink
= le32_to_cpu(info
->NumberOfLinks
);
505 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
506 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
509 int cifs_get_file_info(struct file
*filp
)
513 FILE_ALL_INFO find_data
;
514 struct cifs_fattr fattr
;
515 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
516 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
517 struct cifsTconInfo
*tcon
= cifs_sb
->tcon
;
518 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*) filp
->private_data
;
521 rc
= CIFSSMBQFileInfo(xid
, tcon
, cfile
->netfid
, &find_data
);
522 if (rc
== -EOPNOTSUPP
|| rc
== -EINVAL
) {
524 * FIXME: legacy server -- fall back to path-based call?
525 * for now, just skip revalidating and mark inode for
529 CIFS_I(inode
)->time
= 0;
531 } else if (rc
== -EREMOTE
) {
532 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
538 * don't bother with SFU junk here -- just mark inode as needing
541 cifs_all_info_to_fattr(&fattr
, &find_data
, cifs_sb
, false);
542 fattr
.cf_uniqueid
= CIFS_I(inode
)->uniqueid
;
543 fattr
.cf_flags
|= CIFS_FATTR_NEED_REVAL
;
544 cifs_fattr_to_inode(inode
, &fattr
);
550 int cifs_get_inode_info(struct inode
**pinode
,
551 const unsigned char *full_path
, FILE_ALL_INFO
*pfindData
,
552 struct super_block
*sb
, int xid
, const __u16
*pfid
)
555 struct cifsTconInfo
*pTcon
;
556 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
558 bool adjustTZ
= false;
559 struct cifs_fattr fattr
;
561 pTcon
= cifs_sb
->tcon
;
562 cFYI(1, "Getting info on %s", full_path
);
564 if ((pfindData
== NULL
) && (*pinode
!= NULL
)) {
565 if (CIFS_I(*pinode
)->clientCanCacheRead
) {
566 cFYI(1, "No need to revalidate cached inode sizes");
571 /* if file info not passed in then get it from server */
572 if (pfindData
== NULL
) {
573 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
576 pfindData
= (FILE_ALL_INFO
*)buf
;
578 /* could do find first instead but this returns more info */
579 rc
= CIFSSMBQPathInfo(xid
, pTcon
, full_path
, pfindData
,
581 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
582 CIFS_MOUNT_MAP_SPECIAL_CHR
);
583 /* BB optimize code so we do not make the above call
584 when server claims no NT SMB support and the above call
585 failed at least once - set flag in tcon or mount */
586 if ((rc
== -EOPNOTSUPP
) || (rc
== -EINVAL
)) {
587 rc
= SMBQueryInformation(xid
, pTcon
, full_path
,
588 pfindData
, cifs_sb
->local_nls
,
589 cifs_sb
->mnt_cifs_flags
&
590 CIFS_MOUNT_MAP_SPECIAL_CHR
);
596 cifs_all_info_to_fattr(&fattr
, (FILE_ALL_INFO
*) pfindData
,
598 } else if (rc
== -EREMOTE
) {
599 cifs_create_dfs_fattr(&fattr
, sb
);
606 * If an inode wasn't passed in, then get the inode number
608 * Is an i_ino of zero legal? Can we use that to check if the server
609 * supports returning inode numbers? Are there other sanity checks we
610 * can use to ensure that the server is really filling in that field?
612 * We can not use the IndexNumber field by default from Windows or
613 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
614 * CIFS spec claims that this value is unique within the scope of a
615 * share, and the windows docs hint that it's actually unique
618 * There may be higher info levels that work but are there Windows
619 * server or network appliances for which IndexNumber field is not
622 if (*pinode
== NULL
) {
623 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) {
626 rc1
= CIFSGetSrvInodeNumber(xid
, pTcon
,
627 full_path
, &fattr
.cf_uniqueid
,
629 cifs_sb
->mnt_cifs_flags
&
630 CIFS_MOUNT_MAP_SPECIAL_CHR
);
631 if (rc1
|| !fattr
.cf_uniqueid
) {
632 cFYI(1, "GetSrvInodeNum rc %d", rc1
);
633 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
634 cifs_autodisable_serverino(cifs_sb
);
637 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
640 fattr
.cf_uniqueid
= CIFS_I(*pinode
)->uniqueid
;
643 /* query for SFU type info if supported and needed */
644 if (fattr
.cf_cifsattrs
& ATTR_SYSTEM
&&
645 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
) {
646 tmprc
= cifs_sfu_type(&fattr
, full_path
, cifs_sb
, xid
);
648 cFYI(1, "cifs_sfu_type failed: %d", tmprc
);
651 #ifdef CONFIG_CIFS_EXPERIMENTAL
652 /* fill in 0777 bits from ACL */
653 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
654 cFYI(1, "Getting mode bits from ACL");
655 cifs_acl_to_fattr(cifs_sb
, &fattr
, *pinode
, full_path
, pfid
);
659 /* fill in remaining high mode bits e.g. SUID, VTX */
660 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
)
661 cifs_sfu_mode(&fattr
, full_path
, cifs_sb
, xid
);
664 *pinode
= cifs_iget(sb
, &fattr
);
668 cifs_fattr_to_inode(*pinode
, &fattr
);
676 static const struct inode_operations cifs_ipc_inode_ops
= {
677 .lookup
= cifs_lookup
,
680 char *cifs_build_path_to_root(struct cifs_sb_info
*cifs_sb
)
682 int pplen
= cifs_sb
->prepathlen
;
684 char *full_path
= NULL
;
686 /* if no prefix path, simply set path to the root of share to "" */
688 full_path
= kmalloc(1, GFP_KERNEL
);
694 if (cifs_sb
->tcon
&& (cifs_sb
->tcon
->Flags
& SMB_SHARE_IS_IN_DFS
))
695 dfsplen
= strnlen(cifs_sb
->tcon
->treeName
, MAX_TREE_SIZE
+ 1);
699 full_path
= kmalloc(dfsplen
+ pplen
+ 1, GFP_KERNEL
);
700 if (full_path
== NULL
)
704 strncpy(full_path
, cifs_sb
->tcon
->treeName
, dfsplen
);
705 /* switch slash direction in prepath depending on whether
706 * windows or posix style path names
708 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
) {
710 for (i
= 0; i
< dfsplen
; i
++) {
711 if (full_path
[i
] == '\\')
716 strncpy(full_path
+ dfsplen
, cifs_sb
->prepath
, pplen
);
717 full_path
[dfsplen
+ pplen
] = 0; /* add trailing null */
722 cifs_find_inode(struct inode
*inode
, void *opaque
)
724 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
726 if (CIFS_I(inode
)->uniqueid
!= fattr
->cf_uniqueid
)
730 * uh oh -- it's a directory. We can't use it since hardlinked dirs are
731 * verboten. Disable serverino and return it as if it were found, the
732 * caller can discard it, generate a uniqueid and retry the find
734 if (S_ISDIR(inode
->i_mode
) && !list_empty(&inode
->i_dentry
)) {
735 fattr
->cf_flags
|= CIFS_FATTR_INO_COLLISION
;
736 cifs_autodisable_serverino(CIFS_SB(inode
->i_sb
));
743 cifs_init_inode(struct inode
*inode
, void *opaque
)
745 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
747 CIFS_I(inode
)->uniqueid
= fattr
->cf_uniqueid
;
751 /* Given fattrs, get a corresponding inode */
753 cifs_iget(struct super_block
*sb
, struct cifs_fattr
*fattr
)
759 cFYI(1, "looking for uniqueid=%llu", fattr
->cf_uniqueid
);
761 /* hash down to 32-bits on 32-bit arch */
762 hash
= cifs_uniqueid_to_ino_t(fattr
->cf_uniqueid
);
764 inode
= iget5_locked(sb
, hash
, cifs_find_inode
, cifs_init_inode
, fattr
);
766 /* was there a problematic inode number collision? */
767 if (fattr
->cf_flags
& CIFS_FATTR_INO_COLLISION
) {
769 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
770 fattr
->cf_flags
&= ~CIFS_FATTR_INO_COLLISION
;
771 goto retry_iget5_locked
;
774 cifs_fattr_to_inode(inode
, fattr
);
775 if (sb
->s_flags
& MS_NOATIME
)
776 inode
->i_flags
|= S_NOATIME
| S_NOCMTIME
;
777 if (inode
->i_state
& I_NEW
) {
779 unlock_new_inode(inode
);
786 /* gets root inode */
787 struct inode
*cifs_root_iget(struct super_block
*sb
, unsigned long ino
)
790 struct cifs_sb_info
*cifs_sb
;
791 struct inode
*inode
= NULL
;
795 cifs_sb
= CIFS_SB(sb
);
796 full_path
= cifs_build_path_to_root(cifs_sb
);
797 if (full_path
== NULL
)
798 return ERR_PTR(-ENOMEM
);
801 if (cifs_sb
->tcon
->unix_ext
)
802 rc
= cifs_get_inode_info_unix(&inode
, full_path
, sb
, xid
);
804 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, sb
,
808 return ERR_PTR(-ENOMEM
);
810 if (rc
&& cifs_sb
->tcon
->ipc
) {
811 cFYI(1, "ipc connection - fake read inode");
812 inode
->i_mode
|= S_IFDIR
;
814 inode
->i_op
= &cifs_ipc_inode_ops
;
815 inode
->i_fop
= &simple_dir_operations
;
816 inode
->i_uid
= cifs_sb
->mnt_uid
;
817 inode
->i_gid
= cifs_sb
->mnt_gid
;
827 /* can not call macro FreeXid here since in a void func
828 * TODO: This is no longer true
835 cifs_set_file_info(struct inode
*inode
, struct iattr
*attrs
, int xid
,
836 char *full_path
, __u32 dosattr
)
842 bool set_time
= false;
843 struct cifsFileInfo
*open_file
;
844 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
845 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
846 struct cifsTconInfo
*pTcon
= cifs_sb
->tcon
;
847 FILE_BASIC_INFO info_buf
;
852 if (attrs
->ia_valid
& ATTR_ATIME
) {
854 info_buf
.LastAccessTime
=
855 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_atime
));
857 info_buf
.LastAccessTime
= 0;
859 if (attrs
->ia_valid
& ATTR_MTIME
) {
861 info_buf
.LastWriteTime
=
862 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_mtime
));
864 info_buf
.LastWriteTime
= 0;
867 * Samba throws this field away, but windows may actually use it.
868 * Do not set ctime unless other time stamps are changed explicitly
869 * (i.e. by utimes()) since we would then have a mix of client and
872 if (set_time
&& (attrs
->ia_valid
& ATTR_CTIME
)) {
873 cFYI(1, "CIFS - CTIME changed");
874 info_buf
.ChangeTime
=
875 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_ctime
));
877 info_buf
.ChangeTime
= 0;
879 info_buf
.CreationTime
= 0; /* don't change */
880 info_buf
.Attributes
= cpu_to_le32(dosattr
);
883 * If the file is already open for write, just use that fileid
885 open_file
= find_writable_file(cifsInode
);
887 netfid
= open_file
->netfid
;
888 netpid
= open_file
->pid
;
889 goto set_via_filehandle
;
893 * NT4 apparently returns success on this call, but it doesn't
896 if (!(pTcon
->ses
->flags
& CIFS_SES_NT4
)) {
897 rc
= CIFSSMBSetPathInfo(xid
, pTcon
, full_path
,
898 &info_buf
, cifs_sb
->local_nls
,
899 cifs_sb
->mnt_cifs_flags
&
900 CIFS_MOUNT_MAP_SPECIAL_CHR
);
902 cifsInode
->cifsAttrs
= dosattr
;
904 } else if (rc
!= -EOPNOTSUPP
&& rc
!= -EINVAL
)
908 cFYI(1, "calling SetFileInfo since SetPathInfo for "
909 "times not supported by this server");
910 rc
= CIFSSMBOpen(xid
, pTcon
, full_path
, FILE_OPEN
,
911 SYNCHRONIZE
| FILE_WRITE_ATTRIBUTES
,
912 CREATE_NOT_DIR
, &netfid
, &oplock
,
913 NULL
, cifs_sb
->local_nls
,
914 cifs_sb
->mnt_cifs_flags
&
915 CIFS_MOUNT_MAP_SPECIAL_CHR
);
923 netpid
= current
->tgid
;
926 rc
= CIFSSMBSetFileInfo(xid
, pTcon
, &info_buf
, netfid
, netpid
);
928 cifsInode
->cifsAttrs
= dosattr
;
930 if (open_file
== NULL
)
931 CIFSSMBClose(xid
, pTcon
, netfid
);
933 cifsFileInfo_put(open_file
);
939 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
940 * and rename it to a random name that hopefully won't conflict with
944 cifs_rename_pending_delete(char *full_path
, struct dentry
*dentry
, int xid
)
949 struct inode
*inode
= dentry
->d_inode
;
950 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
951 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
952 struct cifsTconInfo
*tcon
= cifs_sb
->tcon
;
953 __u32 dosattr
, origattr
;
954 FILE_BASIC_INFO
*info_buf
= NULL
;
956 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, FILE_OPEN
,
957 DELETE
|FILE_WRITE_ATTRIBUTES
, CREATE_NOT_DIR
,
958 &netfid
, &oplock
, NULL
, cifs_sb
->local_nls
,
959 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
963 origattr
= cifsInode
->cifsAttrs
;
965 origattr
|= ATTR_NORMAL
;
967 dosattr
= origattr
& ~ATTR_READONLY
;
969 dosattr
|= ATTR_NORMAL
;
970 dosattr
|= ATTR_HIDDEN
;
972 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
973 if (dosattr
!= origattr
) {
974 info_buf
= kzalloc(sizeof(*info_buf
), GFP_KERNEL
);
975 if (info_buf
== NULL
) {
979 info_buf
->Attributes
= cpu_to_le32(dosattr
);
980 rc
= CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, netfid
,
982 /* although we would like to mark the file hidden
983 if that fails we will still try to rename it */
985 cifsInode
->cifsAttrs
= dosattr
;
987 dosattr
= origattr
; /* since not able to change them */
990 /* rename the file */
991 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, netfid
, NULL
, cifs_sb
->local_nls
,
992 cifs_sb
->mnt_cifs_flags
&
993 CIFS_MOUNT_MAP_SPECIAL_CHR
);
999 /* try to set DELETE_ON_CLOSE */
1000 if (!cifsInode
->delete_pending
) {
1001 rc
= CIFSSMBSetFileDisposition(xid
, tcon
, true, netfid
,
1004 * some samba versions return -ENOENT when we try to set the
1005 * file disposition here. Likely a samba bug, but work around
1006 * it for now. This means that some cifsXXX files may hang
1007 * around after they shouldn't.
1009 * BB: remove this hack after more servers have the fix
1017 cifsInode
->delete_pending
= true;
1021 CIFSSMBClose(xid
, tcon
, netfid
);
1027 * reset everything back to the original state. Don't bother
1028 * dealing with errors here since we can't do anything about
1032 CIFSSMBRenameOpenFile(xid
, tcon
, netfid
, dentry
->d_name
.name
,
1033 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1034 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1036 if (dosattr
!= origattr
) {
1037 info_buf
->Attributes
= cpu_to_le32(origattr
);
1038 if (!CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, netfid
,
1040 cifsInode
->cifsAttrs
= origattr
;
1048 * If dentry->d_inode is null (usually meaning the cached dentry
1049 * is a negative dentry) then we would attempt a standard SMB delete, but
1050 * if that fails we can not attempt the fall back mechanisms on EACCESS
1051 * but will return the EACCESS to the caller. Note that the VFS does not call
1052 * unlink on negative dentries currently.
1054 int cifs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1058 char *full_path
= NULL
;
1059 struct inode
*inode
= dentry
->d_inode
;
1060 struct cifsInodeInfo
*cifs_inode
;
1061 struct super_block
*sb
= dir
->i_sb
;
1062 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
1063 struct cifsTconInfo
*tcon
= cifs_sb
->tcon
;
1064 struct iattr
*attrs
= NULL
;
1065 __u32 dosattr
= 0, origattr
= 0;
1067 cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir
, dentry
);
1071 /* Unlink can be called from rename so we can not take the
1072 * sb->s_vfs_rename_mutex here */
1073 full_path
= build_path_from_dentry(dentry
);
1074 if (full_path
== NULL
) {
1080 if ((tcon
->ses
->capabilities
& CAP_UNIX
) &&
1081 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1082 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1083 rc
= CIFSPOSIXDelFile(xid
, tcon
, full_path
,
1084 SMB_POSIX_UNLINK_FILE_TARGET
, cifs_sb
->local_nls
,
1085 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
1086 cFYI(1, "posix del rc %d", rc
);
1087 if ((rc
== 0) || (rc
== -ENOENT
))
1088 goto psx_del_no_retry
;
1092 rc
= CIFSSMBDelFile(xid
, tcon
, full_path
, cifs_sb
->local_nls
,
1093 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
1099 } else if (rc
== -ENOENT
) {
1101 } else if (rc
== -ETXTBSY
) {
1102 rc
= cifs_rename_pending_delete(full_path
, dentry
, xid
);
1105 } else if ((rc
== -EACCES
) && (dosattr
== 0) && inode
) {
1106 attrs
= kzalloc(sizeof(*attrs
), GFP_KERNEL
);
1107 if (attrs
== NULL
) {
1112 /* try to reset dos attributes */
1113 cifs_inode
= CIFS_I(inode
);
1114 origattr
= cifs_inode
->cifsAttrs
;
1116 origattr
|= ATTR_NORMAL
;
1117 dosattr
= origattr
& ~ATTR_READONLY
;
1119 dosattr
|= ATTR_NORMAL
;
1120 dosattr
|= ATTR_HIDDEN
;
1122 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
1126 goto retry_std_delete
;
1129 /* undo the setattr if we errored out and it's needed */
1130 if (rc
!= 0 && dosattr
!= 0)
1131 cifs_set_file_info(inode
, attrs
, xid
, full_path
, origattr
);
1135 cifs_inode
= CIFS_I(inode
);
1136 cifs_inode
->time
= 0; /* will force revalidate to get info
1138 inode
->i_ctime
= current_fs_time(sb
);
1140 dir
->i_ctime
= dir
->i_mtime
= current_fs_time(sb
);
1141 cifs_inode
= CIFS_I(dir
);
1142 CIFS_I(dir
)->time
= 0; /* force revalidate of dir as well */
1150 int cifs_mkdir(struct inode
*inode
, struct dentry
*direntry
, int mode
)
1154 struct cifs_sb_info
*cifs_sb
;
1155 struct cifsTconInfo
*pTcon
;
1156 char *full_path
= NULL
;
1157 struct inode
*newinode
= NULL
;
1158 struct cifs_fattr fattr
;
1160 cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode
, inode
);
1164 cifs_sb
= CIFS_SB(inode
->i_sb
);
1165 pTcon
= cifs_sb
->tcon
;
1167 full_path
= build_path_from_dentry(direntry
);
1168 if (full_path
== NULL
) {
1174 if ((pTcon
->ses
->capabilities
& CAP_UNIX
) &&
1175 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1176 le64_to_cpu(pTcon
->fsUnixInfo
.Capability
))) {
1178 FILE_UNIX_BASIC_INFO
*pInfo
=
1179 kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
1180 if (pInfo
== NULL
) {
1185 mode
&= ~current_umask();
1186 rc
= CIFSPOSIXCreate(xid
, pTcon
, SMB_O_DIRECTORY
| SMB_O_CREAT
,
1187 mode
, NULL
/* netfid */, pInfo
, &oplock
,
1188 full_path
, cifs_sb
->local_nls
,
1189 cifs_sb
->mnt_cifs_flags
&
1190 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1191 if (rc
== -EOPNOTSUPP
) {
1193 goto mkdir_retry_old
;
1195 cFYI(1, "posix mkdir returned 0x%x", rc
);
1198 if (pInfo
->Type
== cpu_to_le32(-1)) {
1199 /* no return info, go query for it */
1201 goto mkdir_get_info
;
1203 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1207 direntry
->d_op
= &cifs_ci_dentry_ops
;
1209 direntry
->d_op
= &cifs_dentry_ops
;
1211 cifs_unix_basic_to_fattr(&fattr
, pInfo
, cifs_sb
);
1212 cifs_fill_uniqueid(inode
->i_sb
, &fattr
);
1213 newinode
= cifs_iget(inode
->i_sb
, &fattr
);
1216 goto mkdir_get_info
;
1219 d_instantiate(direntry
, newinode
);
1221 #ifdef CONFIG_CIFS_DEBUG2
1222 cFYI(1, "instantiated dentry %p %s to inode %p",
1223 direntry
, direntry
->d_name
.name
, newinode
);
1225 if (newinode
->i_nlink
!= 2)
1226 cFYI(1, "unexpected number of links %d",
1234 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1235 rc
= CIFSSMBMkDir(xid
, pTcon
, full_path
, cifs_sb
->local_nls
,
1236 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
1238 cFYI(1, "cifs_mkdir returned 0x%x", rc
);
1243 if (pTcon
->unix_ext
)
1244 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
1247 rc
= cifs_get_inode_info(&newinode
, full_path
, NULL
,
1248 inode
->i_sb
, xid
, NULL
);
1251 direntry
->d_op
= &cifs_ci_dentry_ops
;
1253 direntry
->d_op
= &cifs_dentry_ops
;
1254 d_instantiate(direntry
, newinode
);
1255 /* setting nlink not necessary except in cases where we
1256 * failed to get it from the server or was set bogus */
1257 if ((direntry
->d_inode
) && (direntry
->d_inode
->i_nlink
< 2))
1258 direntry
->d_inode
->i_nlink
= 2;
1260 mode
&= ~current_umask();
1261 /* must turn on setgid bit if parent dir has it */
1262 if (inode
->i_mode
& S_ISGID
)
1265 if (pTcon
->unix_ext
) {
1266 struct cifs_unix_set_info_args args
= {
1268 .ctime
= NO_CHANGE_64
,
1269 .atime
= NO_CHANGE_64
,
1270 .mtime
= NO_CHANGE_64
,
1273 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1274 args
.uid
= (__u64
)current_fsuid();
1275 if (inode
->i_mode
& S_ISGID
)
1276 args
.gid
= (__u64
)inode
->i_gid
;
1278 args
.gid
= (__u64
)current_fsgid();
1280 args
.uid
= NO_CHANGE_64
;
1281 args
.gid
= NO_CHANGE_64
;
1283 CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, &args
,
1285 cifs_sb
->mnt_cifs_flags
&
1286 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1288 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
1289 (mode
& S_IWUGO
) == 0) {
1290 FILE_BASIC_INFO pInfo
;
1291 struct cifsInodeInfo
*cifsInode
;
1294 memset(&pInfo
, 0, sizeof(pInfo
));
1295 cifsInode
= CIFS_I(newinode
);
1296 dosattrs
= cifsInode
->cifsAttrs
|ATTR_READONLY
;
1297 pInfo
.Attributes
= cpu_to_le32(dosattrs
);
1298 tmprc
= CIFSSMBSetPathInfo(xid
, pTcon
,
1301 cifs_sb
->mnt_cifs_flags
&
1302 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1304 cifsInode
->cifsAttrs
= dosattrs
;
1306 if (direntry
->d_inode
) {
1307 if (cifs_sb
->mnt_cifs_flags
&
1309 direntry
->d_inode
->i_mode
=
1312 if (cifs_sb
->mnt_cifs_flags
&
1313 CIFS_MOUNT_SET_UID
) {
1314 direntry
->d_inode
->i_uid
=
1316 if (inode
->i_mode
& S_ISGID
)
1317 direntry
->d_inode
->i_gid
=
1320 direntry
->d_inode
->i_gid
=
1332 int cifs_rmdir(struct inode
*inode
, struct dentry
*direntry
)
1336 struct cifs_sb_info
*cifs_sb
;
1337 struct cifsTconInfo
*pTcon
;
1338 char *full_path
= NULL
;
1339 struct cifsInodeInfo
*cifsInode
;
1341 cFYI(1, "cifs_rmdir, inode = 0x%p", inode
);
1345 cifs_sb
= CIFS_SB(inode
->i_sb
);
1346 pTcon
= cifs_sb
->tcon
;
1348 full_path
= build_path_from_dentry(direntry
);
1349 if (full_path
== NULL
) {
1355 rc
= CIFSSMBRmDir(xid
, pTcon
, full_path
, cifs_sb
->local_nls
,
1356 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
1360 spin_lock(&direntry
->d_inode
->i_lock
);
1361 i_size_write(direntry
->d_inode
, 0);
1362 clear_nlink(direntry
->d_inode
);
1363 spin_unlock(&direntry
->d_inode
->i_lock
);
1366 cifsInode
= CIFS_I(direntry
->d_inode
);
1367 cifsInode
->time
= 0; /* force revalidate to go get info when
1370 cifsInode
= CIFS_I(inode
);
1371 cifsInode
->time
= 0; /* force revalidate to get parent dir info
1372 since cached search results now invalid */
1374 direntry
->d_inode
->i_ctime
= inode
->i_ctime
= inode
->i_mtime
=
1375 current_fs_time(inode
->i_sb
);
1383 cifs_do_rename(int xid
, struct dentry
*from_dentry
, const char *fromPath
,
1384 struct dentry
*to_dentry
, const char *toPath
)
1386 struct cifs_sb_info
*cifs_sb
= CIFS_SB(from_dentry
->d_sb
);
1387 struct cifsTconInfo
*pTcon
= cifs_sb
->tcon
;
1391 /* try path-based rename first */
1392 rc
= CIFSSMBRename(xid
, pTcon
, fromPath
, toPath
, cifs_sb
->local_nls
,
1393 cifs_sb
->mnt_cifs_flags
&
1394 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1397 * don't bother with rename by filehandle unless file is busy and
1398 * source Note that cross directory moves do not work with
1399 * rename by filehandle to various Windows servers.
1401 if (rc
== 0 || rc
!= -ETXTBSY
)
1404 /* open-file renames don't work across directories */
1405 if (to_dentry
->d_parent
!= from_dentry
->d_parent
)
1408 /* open the file to be renamed -- we need DELETE perms */
1409 rc
= CIFSSMBOpen(xid
, pTcon
, fromPath
, FILE_OPEN
, DELETE
,
1410 CREATE_NOT_DIR
, &srcfid
, &oplock
, NULL
,
1411 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1412 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1415 rc
= CIFSSMBRenameOpenFile(xid
, pTcon
, srcfid
,
1416 (const char *) to_dentry
->d_name
.name
,
1417 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1418 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1420 CIFSSMBClose(xid
, pTcon
, srcfid
);
1426 int cifs_rename(struct inode
*source_dir
, struct dentry
*source_dentry
,
1427 struct inode
*target_dir
, struct dentry
*target_dentry
)
1429 char *fromName
= NULL
;
1430 char *toName
= NULL
;
1431 struct cifs_sb_info
*cifs_sb_source
;
1432 struct cifs_sb_info
*cifs_sb_target
;
1433 struct cifsTconInfo
*tcon
;
1434 FILE_UNIX_BASIC_INFO
*info_buf_source
= NULL
;
1435 FILE_UNIX_BASIC_INFO
*info_buf_target
;
1438 cifs_sb_target
= CIFS_SB(target_dir
->i_sb
);
1439 cifs_sb_source
= CIFS_SB(source_dir
->i_sb
);
1440 tcon
= cifs_sb_source
->tcon
;
1445 * BB: this might be allowed if same server, but different share.
1446 * Consider adding support for this
1448 if (tcon
!= cifs_sb_target
->tcon
) {
1450 goto cifs_rename_exit
;
1454 * we already have the rename sem so we do not need to
1455 * grab it again here to protect the path integrity
1457 fromName
= build_path_from_dentry(source_dentry
);
1458 if (fromName
== NULL
) {
1460 goto cifs_rename_exit
;
1463 toName
= build_path_from_dentry(target_dentry
);
1464 if (toName
== NULL
) {
1466 goto cifs_rename_exit
;
1469 rc
= cifs_do_rename(xid
, source_dentry
, fromName
,
1470 target_dentry
, toName
);
1472 if (rc
== -EEXIST
&& tcon
->unix_ext
) {
1474 * Are src and dst hardlinks of same inode? We can
1475 * only tell with unix extensions enabled
1478 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO
),
1480 if (info_buf_source
== NULL
) {
1482 goto cifs_rename_exit
;
1485 info_buf_target
= info_buf_source
+ 1;
1486 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, fromName
,
1488 cifs_sb_source
->local_nls
,
1489 cifs_sb_source
->mnt_cifs_flags
&
1490 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1494 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
,
1495 toName
, info_buf_target
,
1496 cifs_sb_target
->local_nls
,
1497 /* remap based on source sb */
1498 cifs_sb_source
->mnt_cifs_flags
&
1499 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1501 if (tmprc
== 0 && (info_buf_source
->UniqueId
==
1502 info_buf_target
->UniqueId
)) {
1503 /* same file, POSIX says that this is a noop */
1505 goto cifs_rename_exit
;
1507 } /* else ... BB we could add the same check for Windows by
1508 checking the UniqueId via FILE_INTERNAL_INFO */
1511 /* Try unlinking the target dentry if it's not negative */
1512 if (target_dentry
->d_inode
&& (rc
== -EACCES
|| rc
== -EEXIST
)) {
1513 tmprc
= cifs_unlink(target_dir
, target_dentry
);
1515 goto cifs_rename_exit
;
1517 rc
= cifs_do_rename(xid
, source_dentry
, fromName
,
1518 target_dentry
, toName
);
1522 kfree(info_buf_source
);
1530 cifs_inode_needs_reval(struct inode
*inode
)
1532 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
1534 if (cifs_i
->clientCanCacheRead
)
1537 if (!lookupCacheEnabled
)
1540 if (cifs_i
->time
== 0)
1543 /* FIXME: the actimeo should be tunable */
1544 if (time_after_eq(jiffies
, cifs_i
->time
+ HZ
))
1547 /* hardlinked files w/ noserverino get "special" treatment */
1548 if (!(CIFS_SB(inode
->i_sb
)->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) &&
1549 S_ISREG(inode
->i_mode
) && inode
->i_nlink
!= 1)
1555 /* check invalid_mapping flag and zap the cache if it's set */
1557 cifs_invalidate_mapping(struct inode
*inode
)
1560 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
1562 cifs_i
->invalid_mapping
= false;
1564 /* write back any cached data */
1565 if (inode
->i_mapping
&& inode
->i_mapping
->nrpages
!= 0) {
1566 rc
= filemap_write_and_wait(inode
->i_mapping
);
1568 cifs_i
->write_behind_rc
= rc
;
1570 invalidate_remote_inode(inode
);
1573 int cifs_revalidate_file(struct file
*filp
)
1576 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
1578 if (!cifs_inode_needs_reval(inode
))
1581 if (CIFS_SB(inode
->i_sb
)->tcon
->unix_ext
)
1582 rc
= cifs_get_file_info_unix(filp
);
1584 rc
= cifs_get_file_info(filp
);
1587 if (CIFS_I(inode
)->invalid_mapping
)
1588 cifs_invalidate_mapping(inode
);
1593 /* revalidate a dentry's inode attributes */
1594 int cifs_revalidate_dentry(struct dentry
*dentry
)
1598 char *full_path
= NULL
;
1599 struct inode
*inode
= dentry
->d_inode
;
1600 struct super_block
*sb
= dentry
->d_sb
;
1607 if (!cifs_inode_needs_reval(inode
))
1610 /* can not safely grab the rename sem here if rename calls revalidate
1611 since that would deadlock */
1612 full_path
= build_path_from_dentry(dentry
);
1613 if (full_path
== NULL
) {
1618 cFYI(1, "Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1619 "jiffies %ld", full_path
, inode
, inode
->i_count
.counter
,
1620 dentry
, dentry
->d_time
, jiffies
);
1622 if (CIFS_SB(sb
)->tcon
->unix_ext
)
1623 rc
= cifs_get_inode_info_unix(&inode
, full_path
, sb
, xid
);
1625 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, sb
,
1629 if (CIFS_I(inode
)->invalid_mapping
)
1630 cifs_invalidate_mapping(inode
);
1637 int cifs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
1640 int err
= cifs_revalidate_dentry(dentry
);
1642 generic_fillattr(dentry
->d_inode
, stat
);
1643 stat
->blksize
= CIFS_MAX_MSGSIZE
;
1644 stat
->ino
= CIFS_I(dentry
->d_inode
)->uniqueid
;
1649 static int cifs_truncate_page(struct address_space
*mapping
, loff_t from
)
1651 pgoff_t index
= from
>> PAGE_CACHE_SHIFT
;
1652 unsigned offset
= from
& (PAGE_CACHE_SIZE
- 1);
1656 page
= grab_cache_page(mapping
, index
);
1660 zero_user_segment(page
, offset
, PAGE_CACHE_SIZE
);
1662 page_cache_release(page
);
1666 static int cifs_vmtruncate(struct inode
*inode
, loff_t offset
)
1671 spin_lock(&inode
->i_lock
);
1672 err
= inode_newsize_ok(inode
, offset
);
1674 spin_unlock(&inode
->i_lock
);
1678 oldsize
= inode
->i_size
;
1679 i_size_write(inode
, offset
);
1680 spin_unlock(&inode
->i_lock
);
1681 truncate_pagecache(inode
, oldsize
, offset
);
1682 if (inode
->i_op
->truncate
)
1683 inode
->i_op
->truncate(inode
);
1689 cifs_set_file_size(struct inode
*inode
, struct iattr
*attrs
,
1690 int xid
, char *full_path
)
1693 struct cifsFileInfo
*open_file
;
1694 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1695 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1696 struct cifsTconInfo
*pTcon
= cifs_sb
->tcon
;
1699 * To avoid spurious oplock breaks from server, in the case of
1700 * inodes that we already have open, avoid doing path based
1701 * setting of file size if we can do it by handle.
1702 * This keeps our caching token (oplock) and avoids timeouts
1703 * when the local oplock break takes longer to flush
1704 * writebehind data than the SMB timeout for the SetPathInfo
1705 * request would allow
1707 open_file
= find_writable_file(cifsInode
);
1709 __u16 nfid
= open_file
->netfid
;
1710 __u32 npid
= open_file
->pid
;
1711 rc
= CIFSSMBSetFileSize(xid
, pTcon
, attrs
->ia_size
, nfid
,
1713 cifsFileInfo_put(open_file
);
1714 cFYI(1, "SetFSize for attrs rc = %d", rc
);
1715 if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
1716 unsigned int bytes_written
;
1717 rc
= CIFSSMBWrite(xid
, pTcon
, nfid
, 0, attrs
->ia_size
,
1718 &bytes_written
, NULL
, NULL
, 1);
1719 cFYI(1, "Wrt seteof rc %d", rc
);
1725 /* Set file size by pathname rather than by handle
1726 either because no valid, writeable file handle for
1727 it was found or because there was an error setting
1729 rc
= CIFSSMBSetEOF(xid
, pTcon
, full_path
, attrs
->ia_size
,
1730 false, cifs_sb
->local_nls
,
1731 cifs_sb
->mnt_cifs_flags
&
1732 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1733 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc
);
1734 if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
1738 rc
= SMBLegacyOpen(xid
, pTcon
, full_path
,
1739 FILE_OPEN
, GENERIC_WRITE
,
1740 CREATE_NOT_DIR
, &netfid
, &oplock
, NULL
,
1742 cifs_sb
->mnt_cifs_flags
&
1743 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1745 unsigned int bytes_written
;
1746 rc
= CIFSSMBWrite(xid
, pTcon
, netfid
, 0,
1748 &bytes_written
, NULL
,
1750 cFYI(1, "wrt seteof rc %d", rc
);
1751 CIFSSMBClose(xid
, pTcon
, netfid
);
1757 cifsInode
->server_eof
= attrs
->ia_size
;
1758 rc
= cifs_vmtruncate(inode
, attrs
->ia_size
);
1759 cifs_truncate_page(inode
->i_mapping
, inode
->i_size
);
1766 cifs_setattr_unix(struct dentry
*direntry
, struct iattr
*attrs
)
1770 char *full_path
= NULL
;
1771 struct inode
*inode
= direntry
->d_inode
;
1772 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1773 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1774 struct cifsTconInfo
*pTcon
= cifs_sb
->tcon
;
1775 struct cifs_unix_set_info_args
*args
= NULL
;
1776 struct cifsFileInfo
*open_file
;
1778 cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1779 direntry
->d_name
.name
, attrs
->ia_valid
);
1783 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
) == 0) {
1784 /* check if we have permission to change attrs */
1785 rc
= inode_change_ok(inode
, attrs
);
1792 full_path
= build_path_from_dentry(direntry
);
1793 if (full_path
== NULL
) {
1799 * Attempt to flush data before changing attributes. We need to do
1800 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1801 * ownership or mode then we may also need to do this. Here, we take
1802 * the safe way out and just do the flush on all setattr requests. If
1803 * the flush returns error, store it to report later and continue.
1805 * BB: This should be smarter. Why bother flushing pages that
1806 * will be truncated anyway? Also, should we error out here if
1807 * the flush returns error?
1809 rc
= filemap_write_and_wait(inode
->i_mapping
);
1811 cifsInode
->write_behind_rc
= rc
;
1815 if (attrs
->ia_valid
& ATTR_SIZE
) {
1816 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
1821 /* skip mode change if it's just for clearing setuid/setgid */
1822 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
1823 attrs
->ia_valid
&= ~ATTR_MODE
;
1825 args
= kmalloc(sizeof(*args
), GFP_KERNEL
);
1831 /* set up the struct */
1832 if (attrs
->ia_valid
& ATTR_MODE
)
1833 args
->mode
= attrs
->ia_mode
;
1835 args
->mode
= NO_CHANGE_64
;
1837 if (attrs
->ia_valid
& ATTR_UID
)
1838 args
->uid
= attrs
->ia_uid
;
1840 args
->uid
= NO_CHANGE_64
;
1842 if (attrs
->ia_valid
& ATTR_GID
)
1843 args
->gid
= attrs
->ia_gid
;
1845 args
->gid
= NO_CHANGE_64
;
1847 if (attrs
->ia_valid
& ATTR_ATIME
)
1848 args
->atime
= cifs_UnixTimeToNT(attrs
->ia_atime
);
1850 args
->atime
= NO_CHANGE_64
;
1852 if (attrs
->ia_valid
& ATTR_MTIME
)
1853 args
->mtime
= cifs_UnixTimeToNT(attrs
->ia_mtime
);
1855 args
->mtime
= NO_CHANGE_64
;
1857 if (attrs
->ia_valid
& ATTR_CTIME
)
1858 args
->ctime
= cifs_UnixTimeToNT(attrs
->ia_ctime
);
1860 args
->ctime
= NO_CHANGE_64
;
1863 open_file
= find_writable_file(cifsInode
);
1865 u16 nfid
= open_file
->netfid
;
1866 u32 npid
= open_file
->pid
;
1867 rc
= CIFSSMBUnixSetFileInfo(xid
, pTcon
, args
, nfid
, npid
);
1868 cifsFileInfo_put(open_file
);
1870 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, args
,
1872 cifs_sb
->mnt_cifs_flags
&
1873 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1877 rc
= inode_setattr(inode
, attrs
);
1879 /* force revalidate when any of these times are set since some
1880 of the fs types (eg ext3, fat) do not have fine enough
1881 time granularity to match protocol, and we do not have a
1882 a way (yet) to query the server fs's time granularity (and
1883 whether it rounds times down).
1885 if (!rc
&& (attrs
->ia_valid
& (ATTR_MTIME
| ATTR_CTIME
)))
1886 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
) == 0) {
1913 /* check if we have permission to change attrs */
1914 rc
= inode_change_ok(inode
, attrs
);
1922 full_path
= build_path_from_dentry(direntry
);
1923 if (full_path
== NULL
) {
1930 * Attempt to flush data before changing attributes. We need to do
1931 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1932 * ownership or mode then we may also need to do this. Here, we take
1933 * the safe way out and just do the flush on all setattr requests. If
1934 * the flush returns error, store it to report later and continue.
1936 * BB: This should be smarter. Why bother flushing pages that
1937 * will be truncated anyway? Also, should we error out here if
1938 * the flush returns error?
1940 rc
= filemap_write_and_wait(inode
->i_mapping
);
1942 cifsInode
->write_behind_rc
= rc
;
1946 if (attrs
->ia_valid
& ATTR_SIZE
) {
1947 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
1949 goto cifs_setattr_exit
;
1953 * Without unix extensions we can't send ownership changes to the
1954 * server, so silently ignore them. This is consistent with how
1955 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
1956 * CIFSACL support + proper Windows to Unix idmapping, we may be
1957 * able to support this in the future.
1959 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
))
1960 attrs
->ia_valid
&= ~(ATTR_UID
| ATTR_GID
);
1962 /* skip mode change if it's just for clearing setuid/setgid */
1963 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
1964 attrs
->ia_valid
&= ~ATTR_MODE
;
1966 if (attrs
->ia_valid
& ATTR_MODE
) {
1967 cFYI(1, "Mode changed to 0%o", attrs
->ia_mode
);
1968 mode
= attrs
->ia_mode
;
1971 if (attrs
->ia_valid
& ATTR_MODE
) {
1973 #ifdef CONFIG_CIFS_EXPERIMENTAL
1974 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
)
1975 rc
= mode_to_acl(inode
, full_path
, mode
);
1978 if (((mode
& S_IWUGO
) == 0) &&
1979 (cifsInode
->cifsAttrs
& ATTR_READONLY
) == 0) {
1981 dosattr
= cifsInode
->cifsAttrs
| ATTR_READONLY
;
1983 /* fix up mode if we're not using dynperm */
1984 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
) == 0)
1985 attrs
->ia_mode
= inode
->i_mode
& ~S_IWUGO
;
1986 } else if ((mode
& S_IWUGO
) &&
1987 (cifsInode
->cifsAttrs
& ATTR_READONLY
)) {
1989 dosattr
= cifsInode
->cifsAttrs
& ~ATTR_READONLY
;
1990 /* Attributes of 0 are ignored */
1992 dosattr
|= ATTR_NORMAL
;
1994 /* reset local inode permissions to normal */
1995 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
1996 attrs
->ia_mode
&= ~(S_IALLUGO
);
1997 if (S_ISDIR(inode
->i_mode
))
1999 cifs_sb
->mnt_dir_mode
;
2002 cifs_sb
->mnt_file_mode
;
2004 } else if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2005 /* ignore mode change - ATTR_READONLY hasn't changed */
2006 attrs
->ia_valid
&= ~ATTR_MODE
;
2010 if (attrs
->ia_valid
& (ATTR_MTIME
|ATTR_ATIME
|ATTR_CTIME
) ||
2011 ((attrs
->ia_valid
& ATTR_MODE
) && dosattr
)) {
2012 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
2013 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2015 /* Even if error on time set, no sense failing the call if
2016 the server would set the time to a reasonable value anyway,
2017 and this check ensures that we are not being called from
2018 sys_utimes in which case we ought to fail the call back to
2019 the user when the server rejects the call */
2020 if ((rc
) && (attrs
->ia_valid
&
2021 (ATTR_MODE
| ATTR_GID
| ATTR_UID
| ATTR_SIZE
)))
2025 /* do not need local check to inode_check_ok since the server does
2028 rc
= inode_setattr(inode
, attrs
);
2036 cifs_setattr(struct dentry
*direntry
, struct iattr
*attrs
)
2038 struct inode
*inode
= direntry
->d_inode
;
2039 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2040 struct cifsTconInfo
*pTcon
= cifs_sb
->tcon
;
2042 if (pTcon
->unix_ext
)
2043 return cifs_setattr_unix(direntry
, attrs
);
2045 return cifs_setattr_nounix(direntry
, attrs
);
2047 /* BB: add cifs_setattr_legacy for really old servers */
2051 void cifs_delete_inode(struct inode
*inode
)
2053 cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode
);
2054 /* may have to add back in if and when safe distributed caching of
2055 directories added e.g. via FindNotify */