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>
27 #include <linux/mount.h>
28 #include <linux/file.h>
32 #include "cifsproto.h"
33 #include "cifs_debug.h"
34 #include "cifs_fs_sb.h"
37 renew_parental_timestamps(struct dentry
*direntry
)
39 /* BB check if there is a way to get the kernel to do this or if we
42 direntry
->d_time
= jiffies
;
43 direntry
= direntry
->d_parent
;
44 } while (!IS_ROOT(direntry
));
48 cifs_build_path_to_root(struct smb_vol
*vol
, struct cifs_sb_info
*cifs_sb
,
49 struct cifs_tcon
*tcon
)
51 int pplen
= vol
->prepath
? strlen(vol
->prepath
) + 1 : 0;
53 char *full_path
= NULL
;
55 /* if no prefix path, simply set path to the root of share to "" */
57 full_path
= kzalloc(1, GFP_KERNEL
);
61 if (tcon
->Flags
& SMB_SHARE_IS_IN_DFS
)
62 dfsplen
= strnlen(tcon
->treeName
, MAX_TREE_SIZE
+ 1);
66 full_path
= kmalloc(dfsplen
+ pplen
+ 1, GFP_KERNEL
);
67 if (full_path
== NULL
)
71 strncpy(full_path
, tcon
->treeName
, dfsplen
);
72 full_path
[dfsplen
] = CIFS_DIR_SEP(cifs_sb
);
73 strncpy(full_path
+ dfsplen
+ 1, vol
->prepath
, pplen
);
74 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
75 full_path
[dfsplen
+ pplen
] = 0; /* add trailing null */
79 /* Note: caller must free return buffer */
81 build_path_from_dentry(struct dentry
*direntry
)
88 struct cifs_sb_info
*cifs_sb
= CIFS_SB(direntry
->d_sb
);
89 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
92 dirsep
= CIFS_DIR_SEP(cifs_sb
);
93 if (tcon
->Flags
& SMB_SHARE_IS_IN_DFS
)
94 dfsplen
= strnlen(tcon
->treeName
, MAX_TREE_SIZE
+ 1);
99 seq
= read_seqbegin(&rename_lock
);
101 for (temp
= direntry
; !IS_ROOT(temp
);) {
102 namelen
+= (1 + temp
->d_name
.len
);
103 temp
= temp
->d_parent
;
105 cifs_dbg(VFS
, "corrupt dentry\n");
112 full_path
= kmalloc(namelen
+1, GFP_KERNEL
);
113 if (full_path
== NULL
)
115 full_path
[namelen
] = 0; /* trailing null */
117 for (temp
= direntry
; !IS_ROOT(temp
);) {
118 spin_lock(&temp
->d_lock
);
119 namelen
-= 1 + temp
->d_name
.len
;
121 spin_unlock(&temp
->d_lock
);
124 full_path
[namelen
] = dirsep
;
125 strncpy(full_path
+ namelen
+ 1, temp
->d_name
.name
,
127 cifs_dbg(FYI
, "name: %s\n", full_path
+ namelen
);
129 spin_unlock(&temp
->d_lock
);
130 temp
= temp
->d_parent
;
132 cifs_dbg(VFS
, "corrupt dentry\n");
139 if (namelen
!= dfsplen
|| read_seqretry(&rename_lock
, seq
)) {
140 cifs_dbg(FYI
, "did not end path lookup where expected. namelen=%ddfsplen=%d\n",
142 /* presumably this is only possible if racing with a rename
143 of one of the parent directories (we can not lock the dentries
144 above us to prevent this, but retrying should be harmless) */
146 goto cifs_bp_rename_retry
;
148 /* DIR_SEP already set for byte 0 / vs \ but not for
149 subsequent slashes in prepath which currently must
150 be entered the right way - not sure if there is an alternative
151 since the '\' is a valid posix character so we can not switch
152 those safely to '/' if any are found in the middle of the prepath */
153 /* BB test paths to Windows with '/' in the midst of prepath */
156 strncpy(full_path
, tcon
->treeName
, dfsplen
);
157 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
) {
159 for (i
= 0; i
< dfsplen
; i
++) {
160 if (full_path
[i
] == '\\')
169 * Don't allow the separator character in a path component.
170 * The VFS will not allow "/", but "\" is allowed by posix.
173 check_name(struct dentry
*direntry
)
175 struct cifs_sb_info
*cifs_sb
= CIFS_SB(direntry
->d_sb
);
178 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
)) {
179 for (i
= 0; i
< direntry
->d_name
.len
; i
++) {
180 if (direntry
->d_name
.name
[i
] == '\\') {
181 cifs_dbg(FYI
, "Invalid file name\n");
190 /* Inode operations in similar order to how they appear in Linux file fs.h */
193 cifs_do_create(struct inode
*inode
, struct dentry
*direntry
, unsigned int xid
,
194 struct tcon_link
*tlink
, unsigned oflags
, umode_t mode
,
195 __u32
*oplock
, struct cifs_fid
*fid
, int *created
)
198 int create_options
= CREATE_NOT_DIR
;
200 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
201 struct cifs_tcon
*tcon
= tlink_tcon(tlink
);
202 char *full_path
= NULL
;
203 FILE_ALL_INFO
*buf
= NULL
;
204 struct inode
*newinode
= NULL
;
206 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
209 if (tcon
->ses
->server
->oplocks
)
210 *oplock
= REQ_OPLOCK
;
212 full_path
= build_path_from_dentry(direntry
);
213 if (full_path
== NULL
) {
218 if (tcon
->unix_ext
&& cap_unix(tcon
->ses
) && !tcon
->broken_posix_open
&&
219 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
220 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
221 rc
= cifs_posix_open(full_path
, &newinode
, inode
->i_sb
, mode
,
222 oflags
, oplock
, &fid
->netfid
, xid
);
225 if (newinode
== NULL
) {
226 /* query inode info */
227 goto cifs_create_get_file_info
;
230 if (S_ISDIR(newinode
->i_mode
)) {
231 CIFSSMBClose(xid
, tcon
, fid
->netfid
);
237 if (!S_ISREG(newinode
->i_mode
)) {
239 * The server may allow us to open things like
240 * FIFOs, but the client isn't set up to deal
241 * with that. If it's not a regular file, just
242 * close it and proceed as if it were a normal
245 CIFSSMBClose(xid
, tcon
, fid
->netfid
);
246 goto cifs_create_get_file_info
;
248 /* success, no need to query */
249 goto cifs_create_set_dentry
;
252 goto cifs_create_get_file_info
;
257 * EIO could indicate that (posix open) operation is not
258 * supported, despite what server claimed in capability
261 * POSIX open in samba versions 3.3.1 and earlier could
262 * incorrectly fail with invalid parameter.
264 tcon
->broken_posix_open
= true;
270 * EREMOTE indicates DFS junction, which is not handled
271 * in posix open. If either that or op not supported
272 * returned, follow the normal lookup.
280 * fallthrough to retry, using older open call, this is case
281 * where server does not support this SMB level, and falsely
282 * claims capability (also get here for DFS case which should be
283 * rare for path not covered on files)
288 if (OPEN_FMODE(oflags
) & FMODE_READ
)
289 desired_access
|= GENERIC_READ
; /* is this too little? */
290 if (OPEN_FMODE(oflags
) & FMODE_WRITE
)
291 desired_access
|= GENERIC_WRITE
;
293 disposition
= FILE_OVERWRITE_IF
;
294 if ((oflags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
295 disposition
= FILE_CREATE
;
296 else if ((oflags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
297 disposition
= FILE_OVERWRITE_IF
;
298 else if ((oflags
& O_CREAT
) == O_CREAT
)
299 disposition
= FILE_OPEN_IF
;
301 cifs_dbg(FYI
, "Create flag not set in create function\n");
304 * BB add processing to set equivalent of mode - e.g. via CreateX with
308 if (!server
->ops
->open
) {
313 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
320 * if we're not using unix extensions, see if we need to set
321 * ATTR_READONLY on the create call
323 if (!tcon
->unix_ext
&& (mode
& S_IWUGO
) == 0)
324 create_options
|= CREATE_OPTION_READONLY
;
326 if (backup_cred(cifs_sb
))
327 create_options
|= CREATE_OPEN_BACKUP_INTENT
;
329 rc
= server
->ops
->open(xid
, tcon
, full_path
, disposition
,
330 desired_access
, create_options
, fid
, oplock
,
333 cifs_dbg(FYI
, "cifs_create returned 0x%x\n", rc
);
338 * If Open reported that we actually created a file then we now have to
339 * set the mode if possible.
341 if ((tcon
->unix_ext
) && (*oplock
& CIFS_CREATE_ACTION
)) {
342 struct cifs_unix_set_info_args args
= {
344 .ctime
= NO_CHANGE_64
,
345 .atime
= NO_CHANGE_64
,
346 .mtime
= NO_CHANGE_64
,
350 *created
|= FILE_CREATED
;
351 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
352 args
.uid
= current_fsuid();
353 if (inode
->i_mode
& S_ISGID
)
354 args
.gid
= inode
->i_gid
;
356 args
.gid
= current_fsgid();
358 args
.uid
= INVALID_UID
; /* no change */
359 args
.gid
= INVALID_GID
; /* no change */
361 CIFSSMBUnixSetFileInfo(xid
, tcon
, &args
, fid
->netfid
,
365 * BB implement mode setting via Windows security
368 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
370 /* Could set r/o dos attribute if mode & 0222 == 0 */
373 cifs_create_get_file_info
:
374 /* server might mask mode so we have to query for it */
376 rc
= cifs_get_inode_info_unix(&newinode
, full_path
, inode
->i_sb
,
379 rc
= cifs_get_inode_info(&newinode
, full_path
, buf
, inode
->i_sb
,
382 if (server
->ops
->set_lease_key
)
383 server
->ops
->set_lease_key(newinode
, fid
);
384 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
385 newinode
->i_mode
= mode
;
386 if ((*oplock
& CIFS_CREATE_ACTION
) &&
387 (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
)) {
388 newinode
->i_uid
= current_fsuid();
389 if (inode
->i_mode
& S_ISGID
)
390 newinode
->i_gid
= inode
->i_gid
;
392 newinode
->i_gid
= current_fsgid();
397 cifs_create_set_dentry
:
399 cifs_dbg(FYI
, "Create worked, get_inode_info failed rc = %d\n",
404 if (S_ISDIR(newinode
->i_mode
)) {
410 d_add(direntry
, newinode
);
418 if (server
->ops
->close
)
419 server
->ops
->close(xid
, tcon
, fid
);
426 cifs_atomic_open(struct inode
*inode
, struct dentry
*direntry
,
427 struct file
*file
, unsigned oflags
, umode_t mode
,
432 struct tcon_link
*tlink
;
433 struct cifs_tcon
*tcon
;
434 struct TCP_Server_Info
*server
;
436 struct cifs_pending_open open
;
438 struct cifsFileInfo
*file_info
;
441 * Posix open is only called (at lookup time) for file create now. For
442 * opens (rather than creates), because we do not know if it is a file
443 * or directory yet, and current Samba no longer allows us to do posix
444 * open on dirs, we could end up wasting an open call on what turns out
445 * to be a dir. For file opens, we wait to call posix open till
446 * cifs_open. It could be added to atomic_open in the future but the
447 * performance tradeoff of the extra network request when EISDIR or
448 * EACCES is returned would have to be weighed against the 50% reduction
449 * in network traffic in the other paths.
451 if (!(oflags
& O_CREAT
)) {
455 * Check for hashed negative dentry. We have already revalidated
456 * the dentry and it is fine. No need to perform another lookup.
458 if (!d_unhashed(direntry
))
461 res
= cifs_lookup(inode
, direntry
, 0);
465 return finish_no_open(file
, res
);
468 rc
= check_name(direntry
);
474 cifs_dbg(FYI
, "parent inode = 0x%p name is: %s and dentry = 0x%p\n",
475 inode
, direntry
->d_name
.name
, direntry
);
477 tlink
= cifs_sb_tlink(CIFS_SB(inode
->i_sb
));
483 tcon
= tlink_tcon(tlink
);
484 server
= tcon
->ses
->server
;
486 if (server
->ops
->new_lease_key
)
487 server
->ops
->new_lease_key(&fid
);
489 cifs_add_pending_open(&fid
, tlink
, &open
);
491 rc
= cifs_do_create(inode
, direntry
, xid
, tlink
, oflags
, mode
,
492 &oplock
, &fid
, opened
);
495 cifs_del_pending_open(&open
);
499 rc
= finish_open(file
, direntry
, generic_file_open
, opened
);
501 if (server
->ops
->close
)
502 server
->ops
->close(xid
, tcon
, &fid
);
503 cifs_del_pending_open(&open
);
507 file_info
= cifs_new_fileinfo(&fid
, file
, tlink
, oplock
);
508 if (file_info
== NULL
) {
509 if (server
->ops
->close
)
510 server
->ops
->close(xid
, tcon
, &fid
);
511 cifs_del_pending_open(&open
);
517 cifs_put_tlink(tlink
);
523 int cifs_create(struct inode
*inode
, struct dentry
*direntry
, umode_t mode
,
527 unsigned int xid
= get_xid();
529 * BB below access is probably too much for mknod to request
530 * but we have to do query and setpathinfo so requesting
531 * less could fail (unless we want to request getatr and setatr
532 * permissions (only). At least for POSIX we do not have to
535 unsigned oflags
= O_EXCL
| O_CREAT
| O_RDWR
;
536 struct tcon_link
*tlink
;
537 struct cifs_tcon
*tcon
;
538 struct TCP_Server_Info
*server
;
541 int created
= FILE_CREATED
;
543 cifs_dbg(FYI
, "cifs_create parent inode = 0x%p name is: %s and dentry = 0x%p\n",
544 inode
, direntry
->d_name
.name
, direntry
);
546 tlink
= cifs_sb_tlink(CIFS_SB(inode
->i_sb
));
551 tcon
= tlink_tcon(tlink
);
552 server
= tcon
->ses
->server
;
554 if (server
->ops
->new_lease_key
)
555 server
->ops
->new_lease_key(&fid
);
557 rc
= cifs_do_create(inode
, direntry
, xid
, tlink
, oflags
, mode
,
558 &oplock
, &fid
, &created
);
559 if (!rc
&& server
->ops
->close
)
560 server
->ops
->close(xid
, tcon
, &fid
);
562 cifs_put_tlink(tlink
);
568 int cifs_mknod(struct inode
*inode
, struct dentry
*direntry
, umode_t mode
,
573 int create_options
= CREATE_NOT_DIR
| CREATE_OPTION_SPECIAL
;
574 struct cifs_sb_info
*cifs_sb
;
575 struct tcon_link
*tlink
;
576 struct cifs_tcon
*pTcon
;
577 struct cifs_io_parms io_parms
;
578 char *full_path
= NULL
;
579 struct inode
*newinode
= NULL
;
582 FILE_ALL_INFO
*buf
= NULL
;
583 unsigned int bytes_written
;
584 struct win_dev
*pdev
;
586 if (!old_valid_dev(device_number
))
589 cifs_sb
= CIFS_SB(inode
->i_sb
);
590 tlink
= cifs_sb_tlink(cifs_sb
);
592 return PTR_ERR(tlink
);
594 pTcon
= tlink_tcon(tlink
);
598 full_path
= build_path_from_dentry(direntry
);
599 if (full_path
== NULL
) {
604 if (pTcon
->unix_ext
) {
605 struct cifs_unix_set_info_args args
= {
606 .mode
= mode
& ~current_umask(),
607 .ctime
= NO_CHANGE_64
,
608 .atime
= NO_CHANGE_64
,
609 .mtime
= NO_CHANGE_64
,
610 .device
= device_number
,
612 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
613 args
.uid
= current_fsuid();
614 args
.gid
= current_fsgid();
616 args
.uid
= INVALID_UID
; /* no change */
617 args
.gid
= INVALID_GID
; /* no change */
619 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, &args
,
621 cifs_sb
->mnt_cifs_flags
&
622 CIFS_MOUNT_MAP_SPECIAL_CHR
);
626 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
630 d_instantiate(direntry
, newinode
);
634 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
))
638 cifs_dbg(FYI
, "sfu compat create special file\n");
640 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
648 if (backup_cred(cifs_sb
))
649 create_options
|= CREATE_OPEN_BACKUP_INTENT
;
651 rc
= CIFSSMBOpen(xid
, pTcon
, full_path
, FILE_CREATE
,
652 GENERIC_WRITE
, create_options
,
653 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
654 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
658 /* BB Do not bother to decode buf since no local inode yet to put
659 * timestamps in, but we can reuse it safely */
661 pdev
= (struct win_dev
*)buf
;
662 io_parms
.netfid
= fileHandle
;
663 io_parms
.pid
= current
->tgid
;
664 io_parms
.tcon
= pTcon
;
666 io_parms
.length
= sizeof(struct win_dev
);
668 memcpy(pdev
->type
, "IntxCHR", 8);
670 cpu_to_le64(MAJOR(device_number
));
672 cpu_to_le64(MINOR(device_number
));
673 rc
= CIFSSMBWrite(xid
, &io_parms
,
674 &bytes_written
, (char *)pdev
,
676 } else if (S_ISBLK(mode
)) {
677 memcpy(pdev
->type
, "IntxBLK", 8);
679 cpu_to_le64(MAJOR(device_number
));
681 cpu_to_le64(MINOR(device_number
));
682 rc
= CIFSSMBWrite(xid
, &io_parms
,
683 &bytes_written
, (char *)pdev
,
685 } /* else if (S_ISFIFO) */
686 CIFSSMBClose(xid
, pTcon
, fileHandle
);
689 /* FIXME: add code here to set EAs */
695 cifs_put_tlink(tlink
);
700 cifs_lookup(struct inode
*parent_dir_inode
, struct dentry
*direntry
,
704 int rc
= 0; /* to get around spurious gcc warning, set to zero here */
705 struct cifs_sb_info
*cifs_sb
;
706 struct tcon_link
*tlink
;
707 struct cifs_tcon
*pTcon
;
708 struct inode
*newInode
= NULL
;
709 char *full_path
= NULL
;
713 cifs_dbg(FYI
, "parent inode = 0x%p name is: %s and dentry = 0x%p\n",
714 parent_dir_inode
, direntry
->d_name
.name
, direntry
);
716 /* check whether path exists */
718 cifs_sb
= CIFS_SB(parent_dir_inode
->i_sb
);
719 tlink
= cifs_sb_tlink(cifs_sb
);
722 return (struct dentry
*)tlink
;
724 pTcon
= tlink_tcon(tlink
);
726 rc
= check_name(direntry
);
730 /* can not grab the rename sem here since it would
731 deadlock in the cases (beginning of sys_rename itself)
732 in which we already have the sb rename sem */
733 full_path
= build_path_from_dentry(direntry
);
734 if (full_path
== NULL
) {
739 if (direntry
->d_inode
!= NULL
) {
740 cifs_dbg(FYI
, "non-NULL inode in lookup\n");
742 cifs_dbg(FYI
, "NULL inode in lookup\n");
744 cifs_dbg(FYI
, "Full path: %s inode = 0x%p\n",
745 full_path
, direntry
->d_inode
);
747 if (pTcon
->unix_ext
) {
748 rc
= cifs_get_inode_info_unix(&newInode
, full_path
,
749 parent_dir_inode
->i_sb
, xid
);
751 rc
= cifs_get_inode_info(&newInode
, full_path
, NULL
,
752 parent_dir_inode
->i_sb
, xid
, NULL
);
755 if ((rc
== 0) && (newInode
!= NULL
)) {
756 d_add(direntry
, newInode
);
757 /* since paths are not looked up by component - the parent
758 directories are presumed to be good here */
759 renew_parental_timestamps(direntry
);
761 } else if (rc
== -ENOENT
) {
763 direntry
->d_time
= jiffies
;
764 d_add(direntry
, NULL
);
765 /* if it was once a directory (but how can we tell?) we could do
766 shrink_dcache_parent(direntry); */
767 } else if (rc
!= -EACCES
) {
768 cifs_dbg(VFS
, "Unexpected lookup error %d\n", rc
);
769 /* We special case check for Access Denied - since that
770 is a common return code */
775 cifs_put_tlink(tlink
);
781 cifs_d_revalidate(struct dentry
*direntry
, unsigned int flags
)
783 if (flags
& LOOKUP_RCU
)
786 if (direntry
->d_inode
) {
787 if (cifs_revalidate_dentry(direntry
))
791 * If the inode wasn't known to be a dfs entry when
792 * the dentry was instantiated, such as when created
793 * via ->readdir(), it needs to be set now since the
794 * attributes will have been updated by
795 * cifs_revalidate_dentry().
797 if (IS_AUTOMOUNT(direntry
->d_inode
) &&
798 !(direntry
->d_flags
& DCACHE_NEED_AUTOMOUNT
)) {
799 spin_lock(&direntry
->d_lock
);
800 direntry
->d_flags
|= DCACHE_NEED_AUTOMOUNT
;
801 spin_unlock(&direntry
->d_lock
);
809 * This may be nfsd (or something), anyway, we can't see the
810 * intent of this. So, since this can be for creation, drop it.
816 * Drop the negative dentry, in order to make sure to use the
817 * case sensitive name which is specified by user if this is
820 if (flags
& (LOOKUP_CREATE
| LOOKUP_RENAME_TARGET
))
823 if (time_after(jiffies
, direntry
->d_time
+ HZ
) || !lookupCacheEnabled
)
829 /* static int cifs_d_delete(struct dentry *direntry)
833 cifs_dbg(FYI, "In cifs d_delete, name = %s\n", direntry->d_name.name);
838 const struct dentry_operations cifs_dentry_ops
= {
839 .d_revalidate
= cifs_d_revalidate
,
840 .d_automount
= cifs_dfs_d_automount
,
841 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
844 static int cifs_ci_hash(const struct dentry
*dentry
, const struct inode
*inode
,
847 struct nls_table
*codepage
= CIFS_SB(dentry
->d_sb
)->local_nls
;
851 hash
= init_name_hash();
852 for (i
= 0; i
< q
->len
; i
++)
853 hash
= partial_name_hash(nls_tolower(codepage
, q
->name
[i
]),
855 q
->hash
= end_name_hash(hash
);
860 static int cifs_ci_compare(const struct dentry
*parent
,
861 const struct inode
*pinode
,
862 const struct dentry
*dentry
, const struct inode
*inode
,
863 unsigned int len
, const char *str
, const struct qstr
*name
)
865 struct nls_table
*codepage
= CIFS_SB(pinode
->i_sb
)->local_nls
;
867 if ((name
->len
== len
) &&
868 (nls_strnicmp(codepage
, name
->name
, str
, len
) == 0))
873 const struct dentry_operations cifs_ci_dentry_ops
= {
874 .d_revalidate
= cifs_d_revalidate
,
875 .d_hash
= cifs_ci_hash
,
876 .d_compare
= cifs_ci_compare
,
877 .d_automount
= cifs_dfs_d_automount
,