4 * vfs operations that deal with dentries
6 * Copyright (C) International Business Machines Corp., 2002,2009
7 * Author(s): Steve French (sfrench@us.ibm.com)
9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/stat.h>
25 #include <linux/slab.h>
26 #include <linux/namei.h>
30 #include "cifsproto.h"
31 #include "cifs_debug.h"
32 #include "cifs_fs_sb.h"
35 renew_parental_timestamps(struct dentry
*direntry
)
37 /* BB check if there is a way to get the kernel to do this or if we
40 direntry
->d_time
= jiffies
;
41 direntry
= direntry
->d_parent
;
42 } while (!IS_ROOT(direntry
));
45 /* Note: caller must free return buffer */
47 build_path_from_dentry(struct dentry
*direntry
)
55 struct cifs_sb_info
*cifs_sb
;
58 return NULL
; /* not much we can do if dentry is freed and
59 we need to reopen the file after it was closed implicitly
60 when the server crashed */
62 cifs_sb
= CIFS_SB(direntry
->d_sb
);
63 dirsep
= CIFS_DIR_SEP(cifs_sb
);
64 pplen
= cifs_sb
->prepathlen
;
65 if (cifs_sb
->tcon
&& (cifs_sb
->tcon
->Flags
& SMB_SHARE_IS_IN_DFS
))
66 dfsplen
= strnlen(cifs_sb
->tcon
->treeName
, MAX_TREE_SIZE
+ 1);
70 namelen
= pplen
+ dfsplen
;
71 for (temp
= direntry
; !IS_ROOT(temp
);) {
72 namelen
+= (1 + temp
->d_name
.len
);
73 temp
= temp
->d_parent
;
75 cERROR(1, ("corrupt dentry"));
80 full_path
= kmalloc(namelen
+1, GFP_KERNEL
);
81 if (full_path
== NULL
)
83 full_path
[namelen
] = 0; /* trailing null */
84 for (temp
= direntry
; !IS_ROOT(temp
);) {
85 namelen
-= 1 + temp
->d_name
.len
;
89 full_path
[namelen
] = dirsep
;
90 strncpy(full_path
+ namelen
+ 1, temp
->d_name
.name
,
92 cFYI(0, ("name: %s", full_path
+ namelen
));
94 temp
= temp
->d_parent
;
96 cERROR(1, ("corrupt dentry"));
101 if (namelen
!= pplen
+ dfsplen
) {
103 ("did not end path lookup where expected namelen is %d",
105 /* presumably this is only possible if racing with a rename
106 of one of the parent directories (we can not lock the dentries
107 above us to prevent this, but retrying should be harmless) */
109 goto cifs_bp_rename_retry
;
111 /* DIR_SEP already set for byte 0 / vs \ but not for
112 subsequent slashes in prepath which currently must
113 be entered the right way - not sure if there is an alternative
114 since the '\' is a valid posix character so we can not switch
115 those safely to '/' if any are found in the middle of the prepath */
116 /* BB test paths to Windows with '/' in the midst of prepath */
119 strncpy(full_path
, cifs_sb
->tcon
->treeName
, dfsplen
);
120 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
) {
122 for (i
= 0; i
< dfsplen
; i
++) {
123 if (full_path
[i
] == '\\')
128 strncpy(full_path
+ dfsplen
, CIFS_SB(direntry
->d_sb
)->prepath
, pplen
);
133 cifs_fill_fileinfo(struct inode
*newinode
, __u16 fileHandle
,
134 struct cifsTconInfo
*tcon
, bool write_only
)
137 struct cifsFileInfo
*pCifsFile
;
138 struct cifsInodeInfo
*pCifsInode
;
140 pCifsFile
= kzalloc(sizeof(struct cifsFileInfo
), GFP_KERNEL
);
142 if (pCifsFile
== NULL
)
148 pCifsFile
->netfid
= fileHandle
;
149 pCifsFile
->pid
= current
->tgid
;
150 pCifsFile
->pInode
= newinode
;
151 pCifsFile
->invalidHandle
= false;
152 pCifsFile
->closePend
= false;
153 mutex_init(&pCifsFile
->fh_mutex
);
154 mutex_init(&pCifsFile
->lock_mutex
);
155 INIT_LIST_HEAD(&pCifsFile
->llist
);
156 atomic_set(&pCifsFile
->wrtPending
, 0);
158 /* set the following in open now
159 pCifsFile->pfile = file; */
160 write_lock(&GlobalSMBSeslock
);
161 list_add(&pCifsFile
->tlist
, &tcon
->openFileList
);
162 pCifsInode
= CIFS_I(newinode
);
164 /* if readable file instance put first in list*/
166 list_add_tail(&pCifsFile
->flist
,
167 &pCifsInode
->openFileList
);
169 list_add(&pCifsFile
->flist
, &pCifsInode
->openFileList
);
171 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
172 pCifsInode
->clientCanCacheAll
= true;
173 pCifsInode
->clientCanCacheRead
= true;
174 cFYI(1, ("Exclusive Oplock inode %p", newinode
));
175 } else if ((oplock
& 0xF) == OPLOCK_READ
)
176 pCifsInode
->clientCanCacheRead
= true;
178 write_unlock(&GlobalSMBSeslock
);
181 int cifs_posix_open(char *full_path
, struct inode
**pinode
,
182 struct super_block
*sb
, int mode
, int oflags
,
183 int *poplock
, __u16
*pnetfid
, int xid
)
187 bool write_only
= false;
188 FILE_UNIX_BASIC_INFO
*presp_data
;
189 __u32 posix_flags
= 0;
190 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
191 struct cifs_fattr fattr
;
193 cFYI(1, ("posix open %s", full_path
));
195 presp_data
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
196 if (presp_data
== NULL
)
199 /* So far cifs posix extensions can only map the following flags.
200 There are other valid fmode oflags such as FMODE_LSEEK, FMODE_PREAD, but
201 so far we do not seem to need them, and we can treat them as local only */
202 if ((oflags
& (FMODE_READ
| FMODE_WRITE
)) ==
203 (FMODE_READ
| FMODE_WRITE
))
204 posix_flags
= SMB_O_RDWR
;
205 else if (oflags
& FMODE_READ
)
206 posix_flags
= SMB_O_RDONLY
;
207 else if (oflags
& FMODE_WRITE
)
208 posix_flags
= SMB_O_WRONLY
;
209 if (oflags
& O_CREAT
)
210 posix_flags
|= SMB_O_CREAT
;
212 posix_flags
|= SMB_O_EXCL
;
213 if (oflags
& O_TRUNC
)
214 posix_flags
|= SMB_O_TRUNC
;
216 posix_flags
|= SMB_O_SYNC
;
217 if (oflags
& O_DIRECTORY
)
218 posix_flags
|= SMB_O_DIRECTORY
;
219 if (oflags
& O_NOFOLLOW
)
220 posix_flags
|= SMB_O_NOFOLLOW
;
221 if (oflags
& O_DIRECT
)
222 posix_flags
|= SMB_O_DIRECT
;
224 if (!(oflags
& FMODE_READ
))
227 mode
&= ~current_umask();
228 rc
= CIFSPOSIXCreate(xid
, cifs_sb
->tcon
, posix_flags
, mode
,
229 pnetfid
, presp_data
, &oplock
, full_path
,
230 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
231 CIFS_MOUNT_MAP_SPECIAL_CHR
);
235 if (presp_data
->Type
== cpu_to_le32(-1))
236 goto posix_open_ret
; /* open ok, caller does qpathinfo */
239 goto posix_open_ret
; /* caller does not need info */
241 cifs_unix_basic_to_fattr(&fattr
, presp_data
, cifs_sb
);
243 /* get new inode and set it up */
244 if (*pinode
== NULL
) {
245 *pinode
= cifs_iget(sb
, &fattr
);
251 cifs_fattr_to_inode(*pinode
, &fattr
);
254 cifs_fill_fileinfo(*pinode
, *pnetfid
, cifs_sb
->tcon
, write_only
);
261 static void setup_cifs_dentry(struct cifsTconInfo
*tcon
,
262 struct dentry
*direntry
,
263 struct inode
*newinode
)
266 direntry
->d_op
= &cifs_ci_dentry_ops
;
268 direntry
->d_op
= &cifs_dentry_ops
;
269 d_instantiate(direntry
, newinode
);
272 /* Inode operations in similar order to how they appear in Linux file fs.h */
275 cifs_create(struct inode
*inode
, struct dentry
*direntry
, int mode
,
276 struct nameidata
*nd
)
280 int create_options
= CREATE_NOT_DIR
;
283 bool posix_create
= false;
285 * BB below access is probably too much for mknod to request
286 * but we have to do query and setpathinfo so requesting
287 * less could fail (unless we want to request getatr and setatr
288 * permissions (only). At least for POSIX we do not have to
291 int desiredAccess
= GENERIC_READ
| GENERIC_WRITE
;
293 struct cifs_sb_info
*cifs_sb
;
294 struct cifsTconInfo
*tcon
;
295 char *full_path
= NULL
;
296 FILE_ALL_INFO
*buf
= NULL
;
297 struct inode
*newinode
= NULL
;
298 int disposition
= FILE_OVERWRITE_IF
;
299 bool write_only
= false;
303 cifs_sb
= CIFS_SB(inode
->i_sb
);
304 tcon
= cifs_sb
->tcon
;
306 full_path
= build_path_from_dentry(direntry
);
307 if (full_path
== NULL
) {
316 if (nd
&& (nd
->flags
& LOOKUP_OPEN
))
317 oflags
= nd
->intent
.open
.flags
;
321 if (tcon
->unix_ext
&& (tcon
->ses
->capabilities
& CAP_UNIX
) &&
322 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
323 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
324 rc
= cifs_posix_open(full_path
, &newinode
, inode
->i_sb
,
325 mode
, oflags
, &oplock
, &fileHandle
, xid
);
326 /* EIO could indicate that (posix open) operation is not
327 supported, despite what server claimed in capability
328 negotation. EREMOTE indicates DFS junction, which is not
329 handled in posix open */
333 if (newinode
== NULL
) /* query inode info */
334 goto cifs_create_get_file_info
;
335 else /* success, no need to query */
336 goto cifs_create_set_dentry
;
337 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
338 (rc
!= -EOPNOTSUPP
) && (rc
!= -EINVAL
))
339 goto cifs_create_out
;
340 /* else fallthrough to retry, using older open call, this is
341 case where server does not support this SMB level, and
342 falsely claims capability (also get here for DFS case
343 which should be rare for path not covered on files) */
346 if (nd
&& (nd
->flags
& LOOKUP_OPEN
)) {
347 /* if the file is going to stay open, then we
348 need to set the desired access properly */
350 if (oflags
& FMODE_READ
)
351 desiredAccess
|= GENERIC_READ
; /* is this too little? */
352 if (oflags
& FMODE_WRITE
) {
353 desiredAccess
|= GENERIC_WRITE
;
354 if (!(oflags
& FMODE_READ
))
358 if ((oflags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
359 disposition
= FILE_CREATE
;
360 else if ((oflags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
361 disposition
= FILE_OVERWRITE_IF
;
362 else if ((oflags
& O_CREAT
) == O_CREAT
)
363 disposition
= FILE_OPEN_IF
;
365 cFYI(1, ("Create flag not set in create function"));
368 /* BB add processing to set equivalent of mode - e.g. via CreateX with
371 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
379 * if we're not using unix extensions, see if we need to set
380 * ATTR_READONLY on the create call
382 if (!tcon
->unix_ext
&& (mode
& S_IWUGO
) == 0)
383 create_options
|= CREATE_OPTION_READONLY
;
385 if (cifs_sb
->tcon
->ses
->capabilities
& CAP_NT_SMBS
)
386 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
,
387 desiredAccess
, create_options
,
388 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
389 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
391 rc
= -EIO
; /* no NT SMB support fall into legacy open below */
394 /* old server, retry the open legacy style */
395 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, disposition
,
396 desiredAccess
, create_options
,
397 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
398 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
401 cFYI(1, ("cifs_create returned 0x%x", rc
));
402 goto cifs_create_out
;
405 /* If Open reported that we actually created a file
406 then we now have to set the mode if possible */
407 if ((tcon
->unix_ext
) && (oplock
& CIFS_CREATE_ACTION
)) {
408 struct cifs_unix_set_info_args args
= {
410 .ctime
= NO_CHANGE_64
,
411 .atime
= NO_CHANGE_64
,
412 .mtime
= NO_CHANGE_64
,
416 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
417 args
.uid
= (__u64
) current_fsuid();
418 if (inode
->i_mode
& S_ISGID
)
419 args
.gid
= (__u64
) inode
->i_gid
;
421 args
.gid
= (__u64
) current_fsgid();
423 args
.uid
= NO_CHANGE_64
;
424 args
.gid
= NO_CHANGE_64
;
426 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
428 cifs_sb
->mnt_cifs_flags
&
429 CIFS_MOUNT_MAP_SPECIAL_CHR
);
431 /* BB implement mode setting via Windows security
433 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
435 /* Could set r/o dos attribute if mode & 0222 == 0 */
438 cifs_create_get_file_info
:
439 /* server might mask mode so we have to query for it */
441 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
444 rc
= cifs_get_inode_info(&newinode
, full_path
, buf
,
445 inode
->i_sb
, xid
, &fileHandle
);
447 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
448 newinode
->i_mode
= mode
;
449 if ((oplock
& CIFS_CREATE_ACTION
) &&
450 (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
)) {
451 newinode
->i_uid
= current_fsuid();
452 if (inode
->i_mode
& S_ISGID
)
453 newinode
->i_gid
= inode
->i_gid
;
455 newinode
->i_gid
= current_fsgid();
460 cifs_create_set_dentry
:
462 setup_cifs_dentry(tcon
, direntry
, newinode
);
464 cFYI(1, ("Create worked, get_inode_info failed rc = %d", rc
));
466 /* nfsd case - nfs srv does not set nd */
467 if ((nd
== NULL
) || (!(nd
->flags
& LOOKUP_OPEN
))) {
468 /* mknod case - do not leave file open */
469 CIFSSMBClose(xid
, tcon
, fileHandle
);
470 } else if (!(posix_create
) && (newinode
)) {
471 cifs_fill_fileinfo(newinode
, fileHandle
,
472 cifs_sb
->tcon
, write_only
);
481 int cifs_mknod(struct inode
*inode
, struct dentry
*direntry
, int mode
,
486 struct cifs_sb_info
*cifs_sb
;
487 struct cifsTconInfo
*pTcon
;
488 char *full_path
= NULL
;
489 struct inode
*newinode
= NULL
;
491 if (!old_valid_dev(device_number
))
496 cifs_sb
= CIFS_SB(inode
->i_sb
);
497 pTcon
= cifs_sb
->tcon
;
499 full_path
= build_path_from_dentry(direntry
);
500 if (full_path
== NULL
)
502 else if (pTcon
->unix_ext
) {
503 struct cifs_unix_set_info_args args
= {
504 .mode
= mode
& ~current_umask(),
505 .ctime
= NO_CHANGE_64
,
506 .atime
= NO_CHANGE_64
,
507 .mtime
= NO_CHANGE_64
,
508 .device
= device_number
,
510 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
511 args
.uid
= (__u64
) current_fsuid();
512 args
.gid
= (__u64
) current_fsgid();
514 args
.uid
= NO_CHANGE_64
;
515 args
.gid
= NO_CHANGE_64
;
517 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, &args
,
519 cifs_sb
->mnt_cifs_flags
&
520 CIFS_MOUNT_MAP_SPECIAL_CHR
);
523 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
526 direntry
->d_op
= &cifs_ci_dentry_ops
;
528 direntry
->d_op
= &cifs_dentry_ops
;
530 d_instantiate(direntry
, newinode
);
533 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
) {
538 cFYI(1, ("sfu compat create special file"));
540 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
548 rc
= CIFSSMBOpen(xid
, pTcon
, full_path
,
549 FILE_CREATE
, /* fail if exists */
550 GENERIC_WRITE
/* BB would
551 WRITE_OWNER | WRITE_DAC be better? */,
552 /* Create a file and set the
553 file attribute to SYSTEM */
554 CREATE_NOT_DIR
| CREATE_OPTION_SPECIAL
,
555 &fileHandle
, &oplock
, buf
,
557 cifs_sb
->mnt_cifs_flags
&
558 CIFS_MOUNT_MAP_SPECIAL_CHR
);
560 /* BB FIXME - add handling for backlevel servers
561 which need legacy open and check for all
562 calls to SMBOpen for fallback to SMBLeagcyOpen */
564 /* BB Do not bother to decode buf since no
565 local inode yet to put timestamps in,
566 but we can reuse it safely */
567 unsigned int bytes_written
;
568 struct win_dev
*pdev
;
569 pdev
= (struct win_dev
*)buf
;
571 memcpy(pdev
->type
, "IntxCHR", 8);
573 cpu_to_le64(MAJOR(device_number
));
575 cpu_to_le64(MINOR(device_number
));
576 rc
= CIFSSMBWrite(xid
, pTcon
,
578 sizeof(struct win_dev
),
579 0, &bytes_written
, (char *)pdev
,
581 } else if (S_ISBLK(mode
)) {
582 memcpy(pdev
->type
, "IntxBLK", 8);
584 cpu_to_le64(MAJOR(device_number
));
586 cpu_to_le64(MINOR(device_number
));
587 rc
= CIFSSMBWrite(xid
, pTcon
,
589 sizeof(struct win_dev
),
590 0, &bytes_written
, (char *)pdev
,
592 } /* else if(S_ISFIFO */
593 CIFSSMBClose(xid
, pTcon
, fileHandle
);
597 /* add code here to set EAs */
607 cifs_lookup(struct inode
*parent_dir_inode
, struct dentry
*direntry
,
608 struct nameidata
*nd
)
611 int rc
= 0; /* to get around spurious gcc warning, set to zero here */
613 __u16 fileHandle
= 0;
614 bool posix_open
= false;
615 struct cifs_sb_info
*cifs_sb
;
616 struct cifsTconInfo
*pTcon
;
617 struct inode
*newInode
= NULL
;
618 char *full_path
= NULL
;
623 cFYI(1, ("parent inode = 0x%p name is: %s and dentry = 0x%p",
624 parent_dir_inode
, direntry
->d_name
.name
, direntry
));
626 /* check whether path exists */
628 cifs_sb
= CIFS_SB(parent_dir_inode
->i_sb
);
629 pTcon
= cifs_sb
->tcon
;
632 * Don't allow the separator character in a path component.
633 * The VFS will not allow "/", but "\" is allowed by posix.
635 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
)) {
637 for (i
= 0; i
< direntry
->d_name
.len
; i
++)
638 if (direntry
->d_name
.name
[i
] == '\\') {
639 cFYI(1, ("Invalid file name"));
641 return ERR_PTR(-EINVAL
);
646 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
647 * the VFS handle the create.
649 if (nd
&& (nd
->flags
& LOOKUP_EXCL
)) {
650 d_instantiate(direntry
, NULL
);
654 /* can not grab the rename sem here since it would
655 deadlock in the cases (beginning of sys_rename itself)
656 in which we already have the sb rename sem */
657 full_path
= build_path_from_dentry(direntry
);
658 if (full_path
== NULL
) {
660 return ERR_PTR(-ENOMEM
);
663 if (direntry
->d_inode
!= NULL
) {
664 cFYI(1, ("non-NULL inode in lookup"));
666 cFYI(1, ("NULL inode in lookup"));
668 cFYI(1, ("Full path: %s inode = 0x%p", full_path
, direntry
->d_inode
));
670 /* Posix open is only called (at lookup time) for file create now.
671 * For opens (rather than creates), because we do not know if it
672 * is a file or directory yet, and current Samba no longer allows
673 * us to do posix open on dirs, we could end up wasting an open call
674 * on what turns out to be a dir. For file opens, we wait to call posix
675 * open till cifs_open. It could be added here (lookup) in the future
676 * but the performance tradeoff of the extra network request when EISDIR
677 * or EACCES is returned would have to be weighed against the 50%
678 * reduction in network traffic in the other paths.
680 if (pTcon
->unix_ext
) {
681 if (nd
&& !(nd
->flags
& (LOOKUP_PARENT
| LOOKUP_DIRECTORY
)) &&
682 (nd
->flags
& LOOKUP_OPEN
) && !pTcon
->broken_posix_open
&&
683 (nd
->intent
.open
.flags
& O_CREAT
)) {
684 rc
= cifs_posix_open(full_path
, &newInode
,
685 parent_dir_inode
->i_sb
,
686 nd
->intent
.open
.create_mode
,
687 nd
->intent
.open
.flags
, &oplock
,
690 * The check below works around a bug in POSIX
691 * open in samba versions 3.3.1 and earlier where
692 * open could incorrectly fail with invalid parameter.
693 * If either that or op not supported returned, follow
696 if ((rc
== 0) || (rc
== -ENOENT
))
698 else if ((rc
== -EINVAL
) || (rc
!= -EOPNOTSUPP
))
699 pTcon
->broken_posix_open
= true;
702 rc
= cifs_get_inode_info_unix(&newInode
, full_path
,
703 parent_dir_inode
->i_sb
, xid
);
705 rc
= cifs_get_inode_info(&newInode
, full_path
, NULL
,
706 parent_dir_inode
->i_sb
, xid
, NULL
);
708 if ((rc
== 0) && (newInode
!= NULL
)) {
710 direntry
->d_op
= &cifs_ci_dentry_ops
;
712 direntry
->d_op
= &cifs_dentry_ops
;
713 d_add(direntry
, newInode
);
715 filp
= lookup_instantiate_filp(nd
, direntry
, NULL
);
716 /* since paths are not looked up by component - the parent
717 directories are presumed to be good here */
718 renew_parental_timestamps(direntry
);
720 } else if (rc
== -ENOENT
) {
722 direntry
->d_time
= jiffies
;
724 direntry
->d_op
= &cifs_ci_dentry_ops
;
726 direntry
->d_op
= &cifs_dentry_ops
;
727 d_add(direntry
, NULL
);
728 /* if it was once a directory (but how can we tell?) we could do
729 shrink_dcache_parent(direntry); */
730 } else if (rc
!= -EACCES
) {
731 cERROR(1, ("Unexpected lookup error %d", rc
));
732 /* We special case check for Access Denied - since that
733 is a common return code */
742 cifs_d_revalidate(struct dentry
*direntry
, struct nameidata
*nd
)
746 if (direntry
->d_inode
) {
747 if (cifs_revalidate(direntry
))
750 cFYI(1, ("neg dentry 0x%p name = %s",
751 direntry
, direntry
->d_name
.name
));
752 if (time_after(jiffies
, direntry
->d_time
+ HZ
) ||
753 !lookupCacheEnabled
) {
762 /* static int cifs_d_delete(struct dentry *direntry)
766 cFYI(1, ("In cifs d_delete, name = %s", direntry->d_name.name));
771 const struct dentry_operations cifs_dentry_ops
= {
772 .d_revalidate
= cifs_d_revalidate
,
773 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
776 static int cifs_ci_hash(struct dentry
*dentry
, struct qstr
*q
)
778 struct nls_table
*codepage
= CIFS_SB(dentry
->d_inode
->i_sb
)->local_nls
;
782 hash
= init_name_hash();
783 for (i
= 0; i
< q
->len
; i
++)
784 hash
= partial_name_hash(nls_tolower(codepage
, q
->name
[i
]),
786 q
->hash
= end_name_hash(hash
);
791 static int cifs_ci_compare(struct dentry
*dentry
, struct qstr
*a
,
794 struct nls_table
*codepage
= CIFS_SB(dentry
->d_inode
->i_sb
)->local_nls
;
796 if ((a
->len
== b
->len
) &&
797 (nls_strnicmp(codepage
, a
->name
, b
->name
, a
->len
) == 0)) {
799 * To preserve case, don't let an existing negative dentry's
800 * case take precedence. If a is not a negative dentry, this
801 * should have no side effects
803 memcpy((void *)a
->name
, b
->name
, a
->len
);
809 const struct dentry_operations cifs_ci_dentry_ops
= {
810 .d_revalidate
= cifs_d_revalidate
,
811 .d_hash
= cifs_ci_hash
,
812 .d_compare
= cifs_ci_compare
,