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));
47 /* Note: caller must free return buffer */
49 build_path_from_dentry(struct dentry *direntry)
57 struct cifs_sb_info *cifs_sb;
60 return NULL; /* not much we can do if dentry is freed and
61 we need to reopen the file after it was closed implicitly
62 when the server crashed */
64 cifs_sb = CIFS_SB(direntry->d_sb);
65 dirsep = CIFS_DIR_SEP(cifs_sb);
66 pplen = cifs_sb->prepathlen;
67 if (cifs_sb->tcon && (cifs_sb->tcon->Flags & SMB_SHARE_IS_IN_DFS))
68 dfsplen = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE + 1);
72 namelen = pplen + dfsplen;
73 for (temp = direntry; !IS_ROOT(temp);) {
74 namelen += (1 + temp->d_name.len);
75 temp = temp->d_parent;
77 cERROR(1, "corrupt dentry");
82 full_path = kmalloc(namelen+1, GFP_KERNEL);
83 if (full_path == NULL)
85 full_path[namelen] = 0; /* trailing null */
86 for (temp = direntry; !IS_ROOT(temp);) {
87 namelen -= 1 + temp->d_name.len;
91 full_path[namelen] = dirsep;
92 strncpy(full_path + namelen + 1, temp->d_name.name,
94 cFYI(0, "name: %s", full_path + namelen);
96 temp = temp->d_parent;
98 cERROR(1, "corrupt dentry");
103 if (namelen != pplen + dfsplen) {
104 cERROR(1, "did not end path lookup where expected namelen is %d",
106 /* presumably this is only possible if racing with a rename
107 of one of the parent directories (we can not lock the dentries
108 above us to prevent this, but retrying should be harmless) */
110 goto cifs_bp_rename_retry;
112 /* DIR_SEP already set for byte 0 / vs \ but not for
113 subsequent slashes in prepath which currently must
114 be entered the right way - not sure if there is an alternative
115 since the '\' is a valid posix character so we can not switch
116 those safely to '/' if any are found in the middle of the prepath */
117 /* BB test paths to Windows with '/' in the midst of prepath */
120 strncpy(full_path, cifs_sb->tcon->treeName, dfsplen);
121 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
123 for (i = 0; i < dfsplen; i++) {
124 if (full_path[i] == '\\')
129 strncpy(full_path + dfsplen, CIFS_SB(direntry->d_sb)->prepath, pplen);
133 struct cifsFileInfo *
134 cifs_new_fileinfo(struct inode *newinode, __u16 fileHandle,
135 struct file *file, struct vfsmount *mnt, unsigned int oflags)
138 struct cifsFileInfo *pCifsFile;
139 struct cifsInodeInfo *pCifsInode;
140 struct cifs_sb_info *cifs_sb = CIFS_SB(mnt->mnt_sb);
142 pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
143 if (pCifsFile == NULL)
149 pCifsFile->netfid = fileHandle;
150 pCifsFile->pid = current->tgid;
151 pCifsFile->pInode = igrab(newinode);
152 pCifsFile->mnt = mnt;
153 pCifsFile->pfile = file;
154 pCifsFile->invalidHandle = false;
155 pCifsFile->closePend = false;
156 mutex_init(&pCifsFile->fh_mutex);
157 mutex_init(&pCifsFile->lock_mutex);
158 INIT_LIST_HEAD(&pCifsFile->llist);
159 atomic_set(&pCifsFile->count, 1);
160 INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
162 write_lock(&GlobalSMBSeslock);
163 list_add(&pCifsFile->tlist, &cifs_sb->tcon->openFileList);
164 pCifsInode = CIFS_I(newinode);
166 /* if readable file instance put first in list*/
167 if (oflags & FMODE_READ)
168 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
170 list_add_tail(&pCifsFile->flist,
171 &pCifsInode->openFileList);
173 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
174 pCifsInode->clientCanCacheAll = true;
175 pCifsInode->clientCanCacheRead = true;
176 cFYI(1, "Exclusive Oplock inode %p", newinode);
177 } else if ((oplock & 0xF) == OPLOCK_READ)
178 pCifsInode->clientCanCacheRead = true;
180 write_unlock(&GlobalSMBSeslock);
182 file->private_data = pCifsFile;
187 int cifs_posix_open(char *full_path, struct inode **pinode,
188 struct super_block *sb, int mode, int oflags,
189 __u32 *poplock, __u16 *pnetfid, int xid)
192 FILE_UNIX_BASIC_INFO *presp_data;
193 __u32 posix_flags = 0;
194 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
195 struct cifs_fattr fattr;
197 cFYI(1, "posix open %s", full_path);
199 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
200 if (presp_data == NULL)
203 /* So far cifs posix extensions can only map the following flags.
204 There are other valid fmode oflags such as FMODE_LSEEK, FMODE_PREAD, but
205 so far we do not seem to need them, and we can treat them as local only */
206 if ((oflags & (FMODE_READ | FMODE_WRITE)) ==
207 (FMODE_READ | FMODE_WRITE))
208 posix_flags = SMB_O_RDWR;
209 else if (oflags & FMODE_READ)
210 posix_flags = SMB_O_RDONLY;
211 else if (oflags & FMODE_WRITE)
212 posix_flags = SMB_O_WRONLY;
213 if (oflags & O_CREAT)
214 posix_flags |= SMB_O_CREAT;
216 posix_flags |= SMB_O_EXCL;
217 if (oflags & O_TRUNC)
218 posix_flags |= SMB_O_TRUNC;
219 /* be safe and imply O_SYNC for O_DSYNC */
220 if (oflags & O_DSYNC)
221 posix_flags |= SMB_O_SYNC;
222 if (oflags & O_DIRECTORY)
223 posix_flags |= SMB_O_DIRECTORY;
224 if (oflags & O_NOFOLLOW)
225 posix_flags |= SMB_O_NOFOLLOW;
226 if (oflags & O_DIRECT)
227 posix_flags |= SMB_O_DIRECT;
229 mode &= ~current_umask();
230 rc = CIFSPOSIXCreate(xid, cifs_sb->tcon, posix_flags, mode,
231 pnetfid, presp_data, poplock, full_path,
232 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
233 CIFS_MOUNT_MAP_SPECIAL_CHR);
237 if (presp_data->Type == cpu_to_le32(-1))
238 goto posix_open_ret; /* open ok, caller does qpathinfo */
241 goto posix_open_ret; /* caller does not need info */
243 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
245 /* get new inode and set it up */
246 if (*pinode == NULL) {
247 cifs_fill_uniqueid(sb, &fattr);
248 *pinode = cifs_iget(sb, &fattr);
254 cifs_fattr_to_inode(*pinode, &fattr);
262 static void setup_cifs_dentry(struct cifsTconInfo *tcon,
263 struct dentry *direntry,
264 struct inode *newinode)
267 direntry->d_op = &cifs_ci_dentry_ops;
269 direntry->d_op = &cifs_dentry_ops;
270 d_instantiate(direntry, newinode);
273 /* Inode operations in similar order to how they appear in Linux file fs.h */
276 cifs_create(struct inode *inode, struct dentry *direntry, int mode,
277 struct nameidata *nd)
281 int create_options = CREATE_NOT_DIR;
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;
302 cifs_sb = CIFS_SB(inode->i_sb);
303 tcon = cifs_sb->tcon;
305 full_path = build_path_from_dentry(direntry);
306 if (full_path == NULL) {
308 goto cifs_create_out;
314 if (nd && (nd->flags & LOOKUP_OPEN))
315 oflags = nd->intent.open.flags;
317 oflags = FMODE_READ | SMB_O_CREAT;
319 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
320 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
321 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
322 rc = cifs_posix_open(full_path, &newinode,
323 inode->i_sb, mode, oflags, &oplock, &fileHandle, xid);
324 /* EIO could indicate that (posix open) operation is not
325 supported, despite what server claimed in capability
326 negotation. EREMOTE indicates DFS junction, which is not
327 handled in posix open */
330 if (newinode == NULL) /* query inode info */
331 goto cifs_create_get_file_info;
332 else /* success, no need to query */
333 goto cifs_create_set_dentry;
334 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
335 (rc != -EOPNOTSUPP) && (rc != -EINVAL))
336 goto cifs_create_out;
337 /* else fallthrough to retry, using older open call, this is
338 case where server does not support this SMB level, and
339 falsely claims capability (also get here for DFS case
340 which should be rare for path not covered on files) */
343 if (nd && (nd->flags & LOOKUP_OPEN)) {
344 /* if the file is going to stay open, then we
345 need to set the desired access properly */
347 if (oflags & FMODE_READ)
348 desiredAccess |= GENERIC_READ; /* is this too little? */
349 if (oflags & FMODE_WRITE)
350 desiredAccess |= GENERIC_WRITE;
352 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
353 disposition = FILE_CREATE;
354 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
355 disposition = FILE_OVERWRITE_IF;
356 else if ((oflags & O_CREAT) == O_CREAT)
357 disposition = FILE_OPEN_IF;
359 cFYI(1, "Create flag not set in create function");
362 /* BB add processing to set equivalent of mode - e.g. via CreateX with
365 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
368 goto cifs_create_out;
372 * if we're not using unix extensions, see if we need to set
373 * ATTR_READONLY on the create call
375 if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
376 create_options |= CREATE_OPTION_READONLY;
378 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
379 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
380 desiredAccess, create_options,
381 &fileHandle, &oplock, buf, cifs_sb->local_nls,
382 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
384 rc = -EIO; /* no NT SMB support fall into legacy open below */
387 /* old server, retry the open legacy style */
388 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
389 desiredAccess, create_options,
390 &fileHandle, &oplock, buf, cifs_sb->local_nls,
391 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
394 cFYI(1, "cifs_create returned 0x%x", rc);
395 goto cifs_create_out;
398 /* If Open reported that we actually created a file
399 then we now have to set the mode if possible */
400 if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
401 struct cifs_unix_set_info_args args = {
403 .ctime = NO_CHANGE_64,
404 .atime = NO_CHANGE_64,
405 .mtime = NO_CHANGE_64,
409 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
410 args.uid = (__u64) current_fsuid();
411 if (inode->i_mode & S_ISGID)
412 args.gid = (__u64) inode->i_gid;
414 args.gid = (__u64) current_fsgid();
416 args.uid = NO_CHANGE_64;
417 args.gid = NO_CHANGE_64;
419 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
421 cifs_sb->mnt_cifs_flags &
422 CIFS_MOUNT_MAP_SPECIAL_CHR);
424 /* BB implement mode setting via Windows security
426 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
428 /* Could set r/o dos attribute if mode & 0222 == 0 */
431 cifs_create_get_file_info:
432 /* server might mask mode so we have to query for it */
434 rc = cifs_get_inode_info_unix(&newinode, full_path,
437 rc = cifs_get_inode_info(&newinode, full_path, buf,
438 inode->i_sb, xid, &fileHandle);
440 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
441 newinode->i_mode = mode;
442 if ((oplock & CIFS_CREATE_ACTION) &&
443 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
444 newinode->i_uid = current_fsuid();
445 if (inode->i_mode & S_ISGID)
446 newinode->i_gid = inode->i_gid;
448 newinode->i_gid = current_fsgid();
453 cifs_create_set_dentry:
455 setup_cifs_dentry(tcon, direntry, newinode);
457 cFYI(1, "Create worked, get_inode_info failed rc = %d", rc);
459 if (newinode && nd && (nd->flags & LOOKUP_OPEN)) {
460 struct cifsFileInfo *pfile_info;
463 filp = lookup_instantiate_filp(nd, direntry, generic_file_open);
466 CIFSSMBClose(xid, tcon, fileHandle);
467 goto cifs_create_out;
470 pfile_info = cifs_new_fileinfo(newinode, fileHandle, filp,
471 nd->path.mnt, oflags);
472 if (pfile_info == NULL) {
474 CIFSSMBClose(xid, tcon, fileHandle);
478 CIFSSMBClose(xid, tcon, fileHandle);
488 int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
493 struct cifs_sb_info *cifs_sb;
494 struct cifsTconInfo *pTcon;
495 char *full_path = NULL;
496 struct inode *newinode = NULL;
499 FILE_ALL_INFO *buf = NULL;
500 unsigned int bytes_written;
501 struct win_dev *pdev;
503 if (!old_valid_dev(device_number))
508 cifs_sb = CIFS_SB(inode->i_sb);
509 pTcon = cifs_sb->tcon;
511 full_path = build_path_from_dentry(direntry);
512 if (full_path == NULL) {
517 if (pTcon->unix_ext) {
518 struct cifs_unix_set_info_args args = {
519 .mode = mode & ~current_umask(),
520 .ctime = NO_CHANGE_64,
521 .atime = NO_CHANGE_64,
522 .mtime = NO_CHANGE_64,
523 .device = device_number,
525 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
526 args.uid = (__u64) current_fsuid();
527 args.gid = (__u64) current_fsgid();
529 args.uid = NO_CHANGE_64;
530 args.gid = NO_CHANGE_64;
532 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
534 cifs_sb->mnt_cifs_flags &
535 CIFS_MOUNT_MAP_SPECIAL_CHR);
539 rc = cifs_get_inode_info_unix(&newinode, full_path,
542 direntry->d_op = &cifs_ci_dentry_ops;
544 direntry->d_op = &cifs_dentry_ops;
547 d_instantiate(direntry, newinode);
551 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
555 cFYI(1, "sfu compat create special file");
557 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
565 /* FIXME: would WRITE_OWNER | WRITE_DAC be better? */
566 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_CREATE,
567 GENERIC_WRITE, CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,
568 &fileHandle, &oplock, buf, cifs_sb->local_nls,
569 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
573 /* BB Do not bother to decode buf since no local inode yet to put
574 * timestamps in, but we can reuse it safely */
576 pdev = (struct win_dev *)buf;
578 memcpy(pdev->type, "IntxCHR", 8);
580 cpu_to_le64(MAJOR(device_number));
582 cpu_to_le64(MINOR(device_number));
583 rc = CIFSSMBWrite(xid, pTcon,
585 sizeof(struct win_dev),
586 0, &bytes_written, (char *)pdev,
588 } else if (S_ISBLK(mode)) {
589 memcpy(pdev->type, "IntxBLK", 8);
591 cpu_to_le64(MAJOR(device_number));
593 cpu_to_le64(MINOR(device_number));
594 rc = CIFSSMBWrite(xid, pTcon,
596 sizeof(struct win_dev),
597 0, &bytes_written, (char *)pdev,
599 } /* else if (S_ISFIFO) */
600 CIFSSMBClose(xid, pTcon, fileHandle);
603 /* FIXME: add code here to set EAs */
613 cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
614 struct nameidata *nd)
617 int rc = 0; /* to get around spurious gcc warning, set to zero here */
619 __u16 fileHandle = 0;
620 bool posix_open = false;
621 struct cifs_sb_info *cifs_sb;
622 struct cifsTconInfo *pTcon;
623 struct cifsFileInfo *cfile;
624 struct inode *newInode = NULL;
625 char *full_path = NULL;
630 cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
631 parent_dir_inode, direntry->d_name.name, direntry);
633 /* check whether path exists */
635 cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
636 pTcon = cifs_sb->tcon;
639 * Don't allow the separator character in a path component.
640 * The VFS will not allow "/", but "\" is allowed by posix.
642 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
644 for (i = 0; i < direntry->d_name.len; i++)
645 if (direntry->d_name.name[i] == '\\') {
646 cFYI(1, "Invalid file name");
648 return ERR_PTR(-EINVAL);
653 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
654 * the VFS handle the create.
656 if (nd && (nd->flags & LOOKUP_EXCL)) {
657 d_instantiate(direntry, NULL);
661 /* can not grab the rename sem here since it would
662 deadlock in the cases (beginning of sys_rename itself)
663 in which we already have the sb rename sem */
664 full_path = build_path_from_dentry(direntry);
665 if (full_path == NULL) {
667 return ERR_PTR(-ENOMEM);
670 if (direntry->d_inode != NULL) {
671 cFYI(1, "non-NULL inode in lookup");
673 cFYI(1, "NULL inode in lookup");
675 cFYI(1, "Full path: %s inode = 0x%p", full_path, direntry->d_inode);
677 /* Posix open is only called (at lookup time) for file create now.
678 * For opens (rather than creates), because we do not know if it
679 * is a file or directory yet, and current Samba no longer allows
680 * us to do posix open on dirs, we could end up wasting an open call
681 * on what turns out to be a dir. For file opens, we wait to call posix
682 * open till cifs_open. It could be added here (lookup) in the future
683 * but the performance tradeoff of the extra network request when EISDIR
684 * or EACCES is returned would have to be weighed against the 50%
685 * reduction in network traffic in the other paths.
687 if (pTcon->unix_ext) {
688 if (nd && !(nd->flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY)) &&
689 (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
690 (nd->intent.open.flags & O_CREAT)) {
691 rc = cifs_posix_open(full_path, &newInode,
692 parent_dir_inode->i_sb,
693 nd->intent.open.create_mode,
694 nd->intent.open.flags, &oplock,
697 * The check below works around a bug in POSIX
698 * open in samba versions 3.3.1 and earlier where
699 * open could incorrectly fail with invalid parameter.
700 * If either that or op not supported returned, follow
703 if ((rc == 0) || (rc == -ENOENT))
705 else if ((rc == -EINVAL) || (rc != -EOPNOTSUPP))
706 pTcon->broken_posix_open = true;
709 rc = cifs_get_inode_info_unix(&newInode, full_path,
710 parent_dir_inode->i_sb, xid);
712 rc = cifs_get_inode_info(&newInode, full_path, NULL,
713 parent_dir_inode->i_sb, xid, NULL);
715 if ((rc == 0) && (newInode != NULL)) {
717 direntry->d_op = &cifs_ci_dentry_ops;
719 direntry->d_op = &cifs_dentry_ops;
720 d_add(direntry, newInode);
722 filp = lookup_instantiate_filp(nd, direntry,
726 CIFSSMBClose(xid, pTcon, fileHandle);
730 cfile = cifs_new_fileinfo(newInode, fileHandle, filp,
732 nd->intent.open.flags);
735 CIFSSMBClose(xid, pTcon, fileHandle);
740 /* since paths are not looked up by component - the parent
741 directories are presumed to be good here */
742 renew_parental_timestamps(direntry);
744 } else if (rc == -ENOENT) {
746 direntry->d_time = jiffies;
748 direntry->d_op = &cifs_ci_dentry_ops;
750 direntry->d_op = &cifs_dentry_ops;
751 d_add(direntry, NULL);
752 /* if it was once a directory (but how can we tell?) we could do
753 shrink_dcache_parent(direntry); */
754 } else if (rc != -EACCES) {
755 cERROR(1, "Unexpected lookup error %d", rc);
756 /* We special case check for Access Denied - since that
757 is a common return code */
767 cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
771 if (direntry->d_inode) {
772 if (cifs_revalidate_dentry(direntry))
775 cFYI(1, "neg dentry 0x%p name = %s",
776 direntry, direntry->d_name.name);
777 if (time_after(jiffies, direntry->d_time + HZ) ||
778 !lookupCacheEnabled) {
787 /* static int cifs_d_delete(struct dentry *direntry)
791 cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
796 const struct dentry_operations cifs_dentry_ops = {
797 .d_revalidate = cifs_d_revalidate,
798 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
801 static int cifs_ci_hash(struct dentry *dentry, struct qstr *q)
803 struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
807 hash = init_name_hash();
808 for (i = 0; i < q->len; i++)
809 hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
811 q->hash = end_name_hash(hash);
816 static int cifs_ci_compare(struct dentry *dentry, struct qstr *a,
819 struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
821 if ((a->len == b->len) &&
822 (nls_strnicmp(codepage, a->name, b->name, a->len) == 0)) {
824 * To preserve case, don't let an existing negative dentry's
825 * case take precedence. If a is not a negative dentry, this
826 * should have no side effects
828 memcpy((void *)a->name, b->name, a->len);
834 const struct dentry_operations cifs_ci_dentry_ops = {
835 .d_revalidate = cifs_d_revalidate,
836 .d_hash = cifs_ci_hash,
837 .d_compare = cifs_ci_compare,