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"
35 #include "cifs_unicode.h"
38 renew_parental_timestamps(struct dentry
*direntry
)
40 /* BB check if there is a way to get the kernel to do this or if we
43 direntry
->d_time
= jiffies
;
44 direntry
= direntry
->d_parent
;
45 } while (!IS_ROOT(direntry
));
49 cifs_build_path_to_root(struct smb_vol
*vol
, struct cifs_sb_info
*cifs_sb
,
50 struct cifs_tcon
*tcon
)
52 int pplen
= vol
->prepath
? strlen(vol
->prepath
) + 1 : 0;
54 char *full_path
= NULL
;
56 /* if no prefix path, simply set path to the root of share to "" */
58 full_path
= kzalloc(1, GFP_KERNEL
);
62 if (tcon
->Flags
& SMB_SHARE_IS_IN_DFS
)
63 dfsplen
= strnlen(tcon
->treeName
, MAX_TREE_SIZE
+ 1);
67 full_path
= kmalloc(dfsplen
+ pplen
+ 1, GFP_KERNEL
);
68 if (full_path
== NULL
)
72 strncpy(full_path
, tcon
->treeName
, dfsplen
);
73 full_path
[dfsplen
] = CIFS_DIR_SEP(cifs_sb
);
74 strncpy(full_path
+ dfsplen
+ 1, vol
->prepath
, pplen
);
75 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
76 full_path
[dfsplen
+ pplen
] = 0; /* add trailing null */
80 /* Note: caller must free return buffer */
82 build_path_from_dentry(struct dentry
*direntry
)
89 struct cifs_sb_info
*cifs_sb
= CIFS_SB(direntry
->d_sb
);
90 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
93 dirsep
= CIFS_DIR_SEP(cifs_sb
);
94 if (tcon
->Flags
& SMB_SHARE_IS_IN_DFS
)
95 dfsplen
= strnlen(tcon
->treeName
, MAX_TREE_SIZE
+ 1);
100 seq
= read_seqbegin(&rename_lock
);
102 for (temp
= direntry
; !IS_ROOT(temp
);) {
103 namelen
+= (1 + temp
->d_name
.len
);
104 temp
= temp
->d_parent
;
106 cifs_dbg(VFS
, "corrupt dentry\n");
113 full_path
= kmalloc(namelen
+1, GFP_KERNEL
);
114 if (full_path
== NULL
)
116 full_path
[namelen
] = 0; /* trailing null */
118 for (temp
= direntry
; !IS_ROOT(temp
);) {
119 spin_lock(&temp
->d_lock
);
120 namelen
-= 1 + temp
->d_name
.len
;
122 spin_unlock(&temp
->d_lock
);
125 full_path
[namelen
] = dirsep
;
126 strncpy(full_path
+ namelen
+ 1, temp
->d_name
.name
,
128 cifs_dbg(FYI
, "name: %s\n", full_path
+ namelen
);
130 spin_unlock(&temp
->d_lock
);
131 temp
= temp
->d_parent
;
133 cifs_dbg(VFS
, "corrupt dentry\n");
140 if (namelen
!= dfsplen
|| read_seqretry(&rename_lock
, seq
)) {
141 cifs_dbg(FYI
, "did not end path lookup where expected. namelen=%ddfsplen=%d\n",
143 /* presumably this is only possible if racing with a rename
144 of one of the parent directories (we can not lock the dentries
145 above us to prevent this, but retrying should be harmless) */
147 goto cifs_bp_rename_retry
;
149 /* DIR_SEP already set for byte 0 / vs \ but not for
150 subsequent slashes in prepath which currently must
151 be entered the right way - not sure if there is an alternative
152 since the '\' is a valid posix character so we can not switch
153 those safely to '/' if any are found in the middle of the prepath */
154 /* BB test paths to Windows with '/' in the midst of prepath */
157 strncpy(full_path
, tcon
->treeName
, dfsplen
);
158 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
) {
160 for (i
= 0; i
< dfsplen
; i
++) {
161 if (full_path
[i
] == '\\')
170 * Don't allow the separator character in a path component.
171 * The VFS will not allow "/", but "\" is allowed by posix.
174 check_name(struct dentry
*direntry
)
176 struct cifs_sb_info
*cifs_sb
= CIFS_SB(direntry
->d_sb
);
179 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
)) {
180 for (i
= 0; i
< direntry
->d_name
.len
; i
++) {
181 if (direntry
->d_name
.name
[i
] == '\\') {
182 cifs_dbg(FYI
, "Invalid file name\n");
191 /* Inode operations in similar order to how they appear in Linux file fs.h */
194 cifs_do_create(struct inode
*inode
, struct dentry
*direntry
, unsigned int xid
,
195 struct tcon_link
*tlink
, unsigned oflags
, umode_t mode
,
196 __u32
*oplock
, struct cifs_fid
*fid
)
199 int create_options
= CREATE_NOT_DIR
;
201 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
202 struct cifs_tcon
*tcon
= tlink_tcon(tlink
);
203 char *full_path
= NULL
;
204 FILE_ALL_INFO
*buf
= NULL
;
205 struct inode
*newinode
= NULL
;
207 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
208 struct cifs_open_parms oparms
;
211 if (tcon
->ses
->server
->oplocks
)
212 *oplock
= REQ_OPLOCK
;
214 full_path
= build_path_from_dentry(direntry
);
215 if (full_path
== NULL
) {
220 if (tcon
->unix_ext
&& cap_unix(tcon
->ses
) && !tcon
->broken_posix_open
&&
221 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
222 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
223 rc
= cifs_posix_open(full_path
, &newinode
, inode
->i_sb
, mode
,
224 oflags
, oplock
, &fid
->netfid
, xid
);
227 if (newinode
== NULL
) {
228 /* query inode info */
229 goto cifs_create_get_file_info
;
232 if (!S_ISREG(newinode
->i_mode
)) {
234 * The server may allow us to open things like
235 * FIFOs, but the client isn't set up to deal
236 * with that. If it's not a regular file, just
237 * close it and proceed as if it were a normal
240 CIFSSMBClose(xid
, tcon
, fid
->netfid
);
241 goto cifs_create_get_file_info
;
243 /* success, no need to query */
244 goto cifs_create_set_dentry
;
247 goto cifs_create_get_file_info
;
252 * EIO could indicate that (posix open) operation is not
253 * supported, despite what server claimed in capability
256 * POSIX open in samba versions 3.3.1 and earlier could
257 * incorrectly fail with invalid parameter.
259 tcon
->broken_posix_open
= true;
265 * EREMOTE indicates DFS junction, which is not handled
266 * in posix open. If either that or op not supported
267 * returned, follow the normal lookup.
275 * fallthrough to retry, using older open call, this is case
276 * where server does not support this SMB level, and falsely
277 * claims capability (also get here for DFS case which should be
278 * rare for path not covered on files)
283 if (OPEN_FMODE(oflags
) & FMODE_READ
)
284 desired_access
|= GENERIC_READ
; /* is this too little? */
285 if (OPEN_FMODE(oflags
) & FMODE_WRITE
)
286 desired_access
|= GENERIC_WRITE
;
288 disposition
= FILE_OVERWRITE_IF
;
289 if ((oflags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
290 disposition
= FILE_CREATE
;
291 else if ((oflags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
292 disposition
= FILE_OVERWRITE_IF
;
293 else if ((oflags
& O_CREAT
) == O_CREAT
)
294 disposition
= FILE_OPEN_IF
;
296 cifs_dbg(FYI
, "Create flag not set in create function\n");
299 * BB add processing to set equivalent of mode - e.g. via CreateX with
303 if (!server
->ops
->open
) {
308 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
315 * if we're not using unix extensions, see if we need to set
316 * ATTR_READONLY on the create call
318 if (!tcon
->unix_ext
&& (mode
& S_IWUGO
) == 0)
319 create_options
|= CREATE_OPTION_READONLY
;
321 if (backup_cred(cifs_sb
))
322 create_options
|= CREATE_OPEN_BACKUP_INTENT
;
325 oparms
.cifs_sb
= cifs_sb
;
326 oparms
.desired_access
= desired_access
;
327 oparms
.create_options
= create_options
;
328 oparms
.disposition
= disposition
;
329 oparms
.path
= full_path
;
331 oparms
.reconnect
= false;
333 rc
= server
->ops
->open(xid
, &oparms
, oplock
, buf
);
335 cifs_dbg(FYI
, "cifs_create returned 0x%x\n", rc
);
340 * If Open reported that we actually created a file then we now have to
341 * set the mode if possible.
343 if ((tcon
->unix_ext
) && (*oplock
& CIFS_CREATE_ACTION
)) {
344 struct cifs_unix_set_info_args args
= {
346 .ctime
= NO_CHANGE_64
,
347 .atime
= NO_CHANGE_64
,
348 .mtime
= NO_CHANGE_64
,
352 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
353 args
.uid
= current_fsuid();
354 if (inode
->i_mode
& S_ISGID
)
355 args
.gid
= inode
->i_gid
;
357 args
.gid
= current_fsgid();
359 args
.uid
= INVALID_UID
; /* no change */
360 args
.gid
= INVALID_GID
; /* no change */
362 CIFSSMBUnixSetFileInfo(xid
, tcon
, &args
, fid
->netfid
,
366 * BB implement mode setting via Windows security
369 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
371 /* Could set r/o dos attribute if mode & 0222 == 0 */
374 cifs_create_get_file_info
:
375 /* server might mask mode so we have to query for it */
377 rc
= cifs_get_inode_info_unix(&newinode
, full_path
, inode
->i_sb
,
380 rc
= cifs_get_inode_info(&newinode
, full_path
, buf
, inode
->i_sb
,
383 if (server
->ops
->set_lease_key
)
384 server
->ops
->set_lease_key(newinode
, fid
);
385 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
386 newinode
->i_mode
= mode
;
387 if ((*oplock
& CIFS_CREATE_ACTION
) &&
388 (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
)) {
389 newinode
->i_uid
= current_fsuid();
390 if (inode
->i_mode
& S_ISGID
)
391 newinode
->i_gid
= inode
->i_gid
;
393 newinode
->i_gid
= current_fsgid();
398 cifs_create_set_dentry
:
400 cifs_dbg(FYI
, "Create worked, get_inode_info failed rc = %d\n",
402 if (server
->ops
->close
)
403 server
->ops
->close(xid
, tcon
, fid
);
407 d_add(direntry
, newinode
);
416 cifs_atomic_open(struct inode
*inode
, struct dentry
*direntry
,
417 struct file
*file
, unsigned oflags
, umode_t mode
,
422 struct tcon_link
*tlink
;
423 struct cifs_tcon
*tcon
;
424 struct TCP_Server_Info
*server
;
426 struct cifs_pending_open open
;
428 struct cifsFileInfo
*file_info
;
431 * Posix open is only called (at lookup time) for file create now. For
432 * opens (rather than creates), because we do not know if it is a file
433 * or directory yet, and current Samba no longer allows us to do posix
434 * open on dirs, we could end up wasting an open call on what turns out
435 * to be a dir. For file opens, we wait to call posix open till
436 * cifs_open. It could be added to atomic_open in the future but the
437 * performance tradeoff of the extra network request when EISDIR or
438 * EACCES is returned would have to be weighed against the 50% reduction
439 * in network traffic in the other paths.
441 if (!(oflags
& O_CREAT
)) {
445 * Check for hashed negative dentry. We have already revalidated
446 * the dentry and it is fine. No need to perform another lookup.
448 if (!d_unhashed(direntry
))
451 res
= cifs_lookup(inode
, direntry
, 0);
455 return finish_no_open(file
, res
);
458 rc
= check_name(direntry
);
464 cifs_dbg(FYI
, "parent inode = 0x%p name is: %s and dentry = 0x%p\n",
465 inode
, direntry
->d_name
.name
, direntry
);
467 tlink
= cifs_sb_tlink(CIFS_SB(inode
->i_sb
));
473 tcon
= tlink_tcon(tlink
);
474 server
= tcon
->ses
->server
;
476 if (server
->ops
->new_lease_key
)
477 server
->ops
->new_lease_key(&fid
);
479 cifs_add_pending_open(&fid
, tlink
, &open
);
481 rc
= cifs_do_create(inode
, direntry
, xid
, tlink
, oflags
, mode
,
485 cifs_del_pending_open(&open
);
489 if ((oflags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
490 *opened
|= FILE_CREATED
;
492 rc
= finish_open(file
, direntry
, generic_file_open
, opened
);
494 if (server
->ops
->close
)
495 server
->ops
->close(xid
, tcon
, &fid
);
496 cifs_del_pending_open(&open
);
500 file_info
= cifs_new_fileinfo(&fid
, file
, tlink
, oplock
);
501 if (file_info
== NULL
) {
502 if (server
->ops
->close
)
503 server
->ops
->close(xid
, tcon
, &fid
);
504 cifs_del_pending_open(&open
);
510 cifs_put_tlink(tlink
);
516 int cifs_create(struct inode
*inode
, struct dentry
*direntry
, umode_t mode
,
520 unsigned int xid
= get_xid();
522 * BB below access is probably too much for mknod to request
523 * but we have to do query and setpathinfo so requesting
524 * less could fail (unless we want to request getatr and setatr
525 * permissions (only). At least for POSIX we do not have to
528 unsigned oflags
= O_EXCL
| O_CREAT
| O_RDWR
;
529 struct tcon_link
*tlink
;
530 struct cifs_tcon
*tcon
;
531 struct TCP_Server_Info
*server
;
535 cifs_dbg(FYI
, "cifs_create parent inode = 0x%p name is: %s and dentry = 0x%p\n",
536 inode
, direntry
->d_name
.name
, direntry
);
538 tlink
= cifs_sb_tlink(CIFS_SB(inode
->i_sb
));
543 tcon
= tlink_tcon(tlink
);
544 server
= tcon
->ses
->server
;
546 if (server
->ops
->new_lease_key
)
547 server
->ops
->new_lease_key(&fid
);
549 rc
= cifs_do_create(inode
, direntry
, xid
, tlink
, oflags
, mode
,
551 if (!rc
&& server
->ops
->close
)
552 server
->ops
->close(xid
, tcon
, &fid
);
554 cifs_put_tlink(tlink
);
560 int cifs_mknod(struct inode
*inode
, struct dentry
*direntry
, umode_t mode
,
565 int create_options
= CREATE_NOT_DIR
| CREATE_OPTION_SPECIAL
;
566 struct cifs_sb_info
*cifs_sb
;
567 struct tcon_link
*tlink
;
568 struct cifs_tcon
*tcon
;
569 struct cifs_io_parms io_parms
;
570 char *full_path
= NULL
;
571 struct inode
*newinode
= NULL
;
574 struct cifs_open_parms oparms
;
575 FILE_ALL_INFO
*buf
= NULL
;
576 unsigned int bytes_written
;
577 struct win_dev
*pdev
;
579 if (!old_valid_dev(device_number
))
582 cifs_sb
= CIFS_SB(inode
->i_sb
);
583 tlink
= cifs_sb_tlink(cifs_sb
);
585 return PTR_ERR(tlink
);
587 tcon
= tlink_tcon(tlink
);
591 full_path
= build_path_from_dentry(direntry
);
592 if (full_path
== NULL
) {
597 if (tcon
->unix_ext
) {
598 struct cifs_unix_set_info_args args
= {
599 .mode
= mode
& ~current_umask(),
600 .ctime
= NO_CHANGE_64
,
601 .atime
= NO_CHANGE_64
,
602 .mtime
= NO_CHANGE_64
,
603 .device
= device_number
,
605 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
606 args
.uid
= current_fsuid();
607 args
.gid
= current_fsgid();
609 args
.uid
= INVALID_UID
; /* no change */
610 args
.gid
= INVALID_GID
; /* no change */
612 rc
= CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
614 cifs_sb
->mnt_cifs_flags
&
615 CIFS_MOUNT_MAP_SPECIAL_CHR
);
619 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
623 d_instantiate(direntry
, newinode
);
627 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
))
631 cifs_dbg(FYI
, "sfu compat create special file\n");
633 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
641 if (backup_cred(cifs_sb
))
642 create_options
|= CREATE_OPEN_BACKUP_INTENT
;
645 oparms
.cifs_sb
= cifs_sb
;
646 oparms
.desired_access
= GENERIC_WRITE
;
647 oparms
.create_options
= create_options
;
648 oparms
.disposition
= FILE_CREATE
;
649 oparms
.path
= full_path
;
651 oparms
.reconnect
= false;
653 rc
= CIFS_open(xid
, &oparms
, &oplock
, buf
);
658 * BB Do not bother to decode buf since no local inode yet to put
659 * timestamps in, but we can reuse it safely.
662 pdev
= (struct win_dev
*)buf
;
663 io_parms
.netfid
= fid
.netfid
;
664 io_parms
.pid
= current
->tgid
;
665 io_parms
.tcon
= tcon
;
667 io_parms
.length
= sizeof(struct win_dev
);
669 memcpy(pdev
->type
, "IntxCHR", 8);
670 pdev
->major
= cpu_to_le64(MAJOR(device_number
));
671 pdev
->minor
= cpu_to_le64(MINOR(device_number
));
672 rc
= CIFSSMBWrite(xid
, &io_parms
, &bytes_written
, (char *)pdev
,
674 } else if (S_ISBLK(mode
)) {
675 memcpy(pdev
->type
, "IntxBLK", 8);
676 pdev
->major
= cpu_to_le64(MAJOR(device_number
));
677 pdev
->minor
= cpu_to_le64(MINOR(device_number
));
678 rc
= CIFSSMBWrite(xid
, &io_parms
, &bytes_written
, (char *)pdev
,
680 } /* else if (S_ISFIFO) */
681 CIFSSMBClose(xid
, tcon
, fid
.netfid
);
684 /* FIXME: add code here to set EAs */
690 cifs_put_tlink(tlink
);
695 cifs_lookup(struct inode
*parent_dir_inode
, struct dentry
*direntry
,
699 int rc
= 0; /* to get around spurious gcc warning, set to zero here */
700 struct cifs_sb_info
*cifs_sb
;
701 struct tcon_link
*tlink
;
702 struct cifs_tcon
*pTcon
;
703 struct inode
*newInode
= NULL
;
704 char *full_path
= NULL
;
708 cifs_dbg(FYI
, "parent inode = 0x%p name is: %s and dentry = 0x%p\n",
709 parent_dir_inode
, direntry
->d_name
.name
, direntry
);
711 /* check whether path exists */
713 cifs_sb
= CIFS_SB(parent_dir_inode
->i_sb
);
714 tlink
= cifs_sb_tlink(cifs_sb
);
717 return (struct dentry
*)tlink
;
719 pTcon
= tlink_tcon(tlink
);
721 rc
= check_name(direntry
);
725 /* can not grab the rename sem here since it would
726 deadlock in the cases (beginning of sys_rename itself)
727 in which we already have the sb rename sem */
728 full_path
= build_path_from_dentry(direntry
);
729 if (full_path
== NULL
) {
734 if (direntry
->d_inode
!= NULL
) {
735 cifs_dbg(FYI
, "non-NULL inode in lookup\n");
737 cifs_dbg(FYI
, "NULL inode in lookup\n");
739 cifs_dbg(FYI
, "Full path: %s inode = 0x%p\n",
740 full_path
, direntry
->d_inode
);
742 if (pTcon
->unix_ext
) {
743 rc
= cifs_get_inode_info_unix(&newInode
, full_path
,
744 parent_dir_inode
->i_sb
, xid
);
746 rc
= cifs_get_inode_info(&newInode
, full_path
, NULL
,
747 parent_dir_inode
->i_sb
, xid
, NULL
);
750 if ((rc
== 0) && (newInode
!= NULL
)) {
751 d_add(direntry
, newInode
);
752 /* since paths are not looked up by component - the parent
753 directories are presumed to be good here */
754 renew_parental_timestamps(direntry
);
756 } else if (rc
== -ENOENT
) {
758 direntry
->d_time
= jiffies
;
759 d_add(direntry
, NULL
);
760 /* if it was once a directory (but how can we tell?) we could do
761 shrink_dcache_parent(direntry); */
762 } else if (rc
!= -EACCES
) {
763 cifs_dbg(FYI
, "Unexpected lookup error %d\n", rc
);
764 /* We special case check for Access Denied - since that
765 is a common return code */
770 cifs_put_tlink(tlink
);
776 cifs_d_revalidate(struct dentry
*direntry
, unsigned int flags
)
778 if (flags
& LOOKUP_RCU
)
781 if (direntry
->d_inode
) {
782 if (cifs_revalidate_dentry(direntry
))
786 * If the inode wasn't known to be a dfs entry when
787 * the dentry was instantiated, such as when created
788 * via ->readdir(), it needs to be set now since the
789 * attributes will have been updated by
790 * cifs_revalidate_dentry().
792 if (IS_AUTOMOUNT(direntry
->d_inode
) &&
793 !(direntry
->d_flags
& DCACHE_NEED_AUTOMOUNT
)) {
794 spin_lock(&direntry
->d_lock
);
795 direntry
->d_flags
|= DCACHE_NEED_AUTOMOUNT
;
796 spin_unlock(&direntry
->d_lock
);
804 * This may be nfsd (or something), anyway, we can't see the
805 * intent of this. So, since this can be for creation, drop it.
811 * Drop the negative dentry, in order to make sure to use the
812 * case sensitive name which is specified by user if this is
815 if (flags
& (LOOKUP_CREATE
| LOOKUP_RENAME_TARGET
))
818 if (time_after(jiffies
, direntry
->d_time
+ HZ
) || !lookupCacheEnabled
)
824 /* static int cifs_d_delete(struct dentry *direntry)
828 cifs_dbg(FYI, "In cifs d_delete, name = %s\n", direntry->d_name.name);
833 const struct dentry_operations cifs_dentry_ops
= {
834 .d_revalidate
= cifs_d_revalidate
,
835 .d_automount
= cifs_dfs_d_automount
,
836 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
839 static int cifs_ci_hash(const struct dentry
*dentry
, struct qstr
*q
)
841 struct nls_table
*codepage
= CIFS_SB(dentry
->d_sb
)->local_nls
;
846 hash
= init_name_hash();
847 for (i
= 0; i
< q
->len
; i
+= charlen
) {
848 charlen
= codepage
->char2uni(&q
->name
[i
], q
->len
- i
, &c
);
849 /* error out if we can't convert the character */
850 if (unlikely(charlen
< 0))
852 hash
= partial_name_hash(cifs_toupper(c
), hash
);
854 q
->hash
= end_name_hash(hash
);
859 static int cifs_ci_compare(const struct dentry
*parent
, const struct dentry
*dentry
,
860 unsigned int len
, const char *str
, const struct qstr
*name
)
862 struct nls_table
*codepage
= CIFS_SB(parent
->d_sb
)->local_nls
;
867 * We make the assumption here that uppercase characters in the local
868 * codepage are always the same length as their lowercase counterparts.
870 * If that's ever not the case, then this will fail to match it.
872 if (name
->len
!= len
)
875 for (i
= 0; i
< len
; i
+= l1
) {
876 /* Convert characters in both strings to UTF-16. */
877 l1
= codepage
->char2uni(&str
[i
], len
- i
, &c1
);
878 l2
= codepage
->char2uni(&name
->name
[i
], name
->len
- i
, &c2
);
881 * If we can't convert either character, just declare it to
882 * be 1 byte long and compare the original byte.
884 if (unlikely(l1
< 0 && l2
< 0)) {
885 if (str
[i
] != name
->name
[i
])
892 * Here, we again ass|u|me that upper/lowercase versions of
893 * a character are the same length in the local NLS.
898 /* Now compare uppercase versions of these characters */
899 if (cifs_toupper(c1
) != cifs_toupper(c2
))
906 const struct dentry_operations cifs_ci_dentry_ops
= {
907 .d_revalidate
= cifs_d_revalidate
,
908 .d_hash
= cifs_ci_hash
,
909 .d_compare
= cifs_ci_compare
,
910 .d_automount
= cifs_dfs_d_automount
,