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);
134 * When called with struct file pointer set to NULL, there is no way we could
135 * update file->private_data, but getting it stuck on openFileList provides a
136 * way to access it from cifs_fill_filedata and thereby set file->private_data
139 struct cifsFileInfo *
140 cifs_new_fileinfo(struct inode *newinode, __u16 fileHandle,
141 struct file *file, struct vfsmount *mnt, unsigned int oflags)
144 struct cifsFileInfo *pCifsFile;
145 struct cifsInodeInfo *pCifsInode;
146 struct cifs_sb_info *cifs_sb = CIFS_SB(mnt->mnt_sb);
148 pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
149 if (pCifsFile == NULL)
155 pCifsFile->netfid = fileHandle;
156 pCifsFile->pid = current->tgid;
157 pCifsFile->pInode = igrab(newinode);
158 pCifsFile->mnt = mnt;
159 pCifsFile->pfile = file;
160 pCifsFile->invalidHandle = false;
161 pCifsFile->closePend = false;
162 mutex_init(&pCifsFile->fh_mutex);
163 mutex_init(&pCifsFile->lock_mutex);
164 INIT_LIST_HEAD(&pCifsFile->llist);
165 atomic_set(&pCifsFile->count, 1);
166 slow_work_init(&pCifsFile->oplock_break, &cifs_oplock_break_ops);
168 write_lock(&GlobalSMBSeslock);
169 list_add(&pCifsFile->tlist, &cifs_sb->tcon->openFileList);
170 pCifsInode = CIFS_I(newinode);
172 /* if readable file instance put first in list*/
173 if (oflags & FMODE_READ)
174 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
176 list_add_tail(&pCifsFile->flist,
177 &pCifsInode->openFileList);
179 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
180 pCifsInode->clientCanCacheAll = true;
181 pCifsInode->clientCanCacheRead = true;
182 cFYI(1, "Exclusive Oplock inode %p", newinode);
183 } else if ((oplock & 0xF) == OPLOCK_READ)
184 pCifsInode->clientCanCacheRead = true;
186 write_unlock(&GlobalSMBSeslock);
188 file->private_data = pCifsFile;
193 int cifs_posix_open(char *full_path, struct inode **pinode,
194 struct super_block *sb, int mode, int oflags,
195 __u32 *poplock, __u16 *pnetfid, int xid)
198 FILE_UNIX_BASIC_INFO *presp_data;
199 __u32 posix_flags = 0;
200 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
201 struct cifs_fattr fattr;
203 cFYI(1, "posix open %s", full_path);
205 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
206 if (presp_data == NULL)
209 /* So far cifs posix extensions can only map the following flags.
210 There are other valid fmode oflags such as FMODE_LSEEK, FMODE_PREAD, but
211 so far we do not seem to need them, and we can treat them as local only */
212 if ((oflags & (FMODE_READ | FMODE_WRITE)) ==
213 (FMODE_READ | FMODE_WRITE))
214 posix_flags = SMB_O_RDWR;
215 else if (oflags & FMODE_READ)
216 posix_flags = SMB_O_RDONLY;
217 else if (oflags & FMODE_WRITE)
218 posix_flags = SMB_O_WRONLY;
219 if (oflags & O_CREAT)
220 posix_flags |= SMB_O_CREAT;
222 posix_flags |= SMB_O_EXCL;
223 if (oflags & O_TRUNC)
224 posix_flags |= SMB_O_TRUNC;
225 /* be safe and imply O_SYNC for O_DSYNC */
226 if (oflags & O_DSYNC)
227 posix_flags |= SMB_O_SYNC;
228 if (oflags & O_DIRECTORY)
229 posix_flags |= SMB_O_DIRECTORY;
230 if (oflags & O_NOFOLLOW)
231 posix_flags |= SMB_O_NOFOLLOW;
232 if (oflags & O_DIRECT)
233 posix_flags |= SMB_O_DIRECT;
235 mode &= ~current_umask();
236 rc = CIFSPOSIXCreate(xid, cifs_sb->tcon, posix_flags, mode,
237 pnetfid, presp_data, poplock, full_path,
238 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
239 CIFS_MOUNT_MAP_SPECIAL_CHR);
243 if (presp_data->Type == cpu_to_le32(-1))
244 goto posix_open_ret; /* open ok, caller does qpathinfo */
247 goto posix_open_ret; /* caller does not need info */
249 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
251 /* get new inode and set it up */
252 if (*pinode == NULL) {
253 cifs_fill_uniqueid(sb, &fattr);
254 *pinode = cifs_iget(sb, &fattr);
260 cifs_fattr_to_inode(*pinode, &fattr);
268 static void setup_cifs_dentry(struct cifsTconInfo *tcon,
269 struct dentry *direntry,
270 struct inode *newinode)
273 direntry->d_op = &cifs_ci_dentry_ops;
275 direntry->d_op = &cifs_dentry_ops;
276 d_instantiate(direntry, newinode);
279 /* Inode operations in similar order to how they appear in Linux file fs.h */
282 cifs_create(struct inode *inode, struct dentry *direntry, int mode,
283 struct nameidata *nd)
287 int create_options = CREATE_NOT_DIR;
291 * BB below access is probably too much for mknod to request
292 * but we have to do query and setpathinfo so requesting
293 * less could fail (unless we want to request getatr and setatr
294 * permissions (only). At least for POSIX we do not have to
297 int desiredAccess = GENERIC_READ | GENERIC_WRITE;
299 struct cifs_sb_info *cifs_sb;
300 struct cifsTconInfo *tcon;
301 char *full_path = NULL;
302 FILE_ALL_INFO *buf = NULL;
303 struct inode *newinode = NULL;
304 int disposition = FILE_OVERWRITE_IF;
308 cifs_sb = CIFS_SB(inode->i_sb);
309 tcon = cifs_sb->tcon;
311 full_path = build_path_from_dentry(direntry);
312 if (full_path == NULL) {
321 if (nd && (nd->flags & LOOKUP_OPEN))
322 oflags = nd->intent.open.flags;
324 oflags = FMODE_READ | SMB_O_CREAT;
326 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
327 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
328 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
329 rc = cifs_posix_open(full_path, &newinode,
330 inode->i_sb, mode, oflags, &oplock, &fileHandle, xid);
331 /* EIO could indicate that (posix open) operation is not
332 supported, despite what server claimed in capability
333 negotation. EREMOTE indicates DFS junction, which is not
334 handled in posix open */
337 if (newinode == NULL) /* query inode info */
338 goto cifs_create_get_file_info;
339 else /* success, no need to query */
340 goto cifs_create_set_dentry;
341 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
342 (rc != -EOPNOTSUPP) && (rc != -EINVAL))
343 goto cifs_create_out;
344 /* else fallthrough to retry, using older open call, this is
345 case where server does not support this SMB level, and
346 falsely claims capability (also get here for DFS case
347 which should be rare for path not covered on files) */
350 if (nd && (nd->flags & LOOKUP_OPEN)) {
351 /* if the file is going to stay open, then we
352 need to set the desired access properly */
354 if (oflags & FMODE_READ)
355 desiredAccess |= GENERIC_READ; /* is this too little? */
356 if (oflags & FMODE_WRITE)
357 desiredAccess |= GENERIC_WRITE;
359 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
360 disposition = FILE_CREATE;
361 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
362 disposition = FILE_OVERWRITE_IF;
363 else if ((oflags & O_CREAT) == O_CREAT)
364 disposition = FILE_OPEN_IF;
366 cFYI(1, "Create flag not set in create function");
369 /* BB add processing to set equivalent of mode - e.g. via CreateX with
372 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
380 * if we're not using unix extensions, see if we need to set
381 * ATTR_READONLY on the create call
383 if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
384 create_options |= CREATE_OPTION_READONLY;
386 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
387 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
388 desiredAccess, create_options,
389 &fileHandle, &oplock, buf, cifs_sb->local_nls,
390 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
392 rc = -EIO; /* no NT SMB support fall into legacy open below */
395 /* old server, retry the open legacy style */
396 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
397 desiredAccess, create_options,
398 &fileHandle, &oplock, buf, cifs_sb->local_nls,
399 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
402 cFYI(1, "cifs_create returned 0x%x", rc);
403 goto cifs_create_out;
406 /* If Open reported that we actually created a file
407 then we now have to set the mode if possible */
408 if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
409 struct cifs_unix_set_info_args args = {
411 .ctime = NO_CHANGE_64,
412 .atime = NO_CHANGE_64,
413 .mtime = NO_CHANGE_64,
417 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
418 args.uid = (__u64) current_fsuid();
419 if (inode->i_mode & S_ISGID)
420 args.gid = (__u64) inode->i_gid;
422 args.gid = (__u64) current_fsgid();
424 args.uid = NO_CHANGE_64;
425 args.gid = NO_CHANGE_64;
427 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
429 cifs_sb->mnt_cifs_flags &
430 CIFS_MOUNT_MAP_SPECIAL_CHR);
432 /* BB implement mode setting via Windows security
434 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
436 /* Could set r/o dos attribute if mode & 0222 == 0 */
439 cifs_create_get_file_info:
440 /* server might mask mode so we have to query for it */
442 rc = cifs_get_inode_info_unix(&newinode, full_path,
445 rc = cifs_get_inode_info(&newinode, full_path, buf,
446 inode->i_sb, xid, &fileHandle);
448 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
449 newinode->i_mode = mode;
450 if ((oplock & CIFS_CREATE_ACTION) &&
451 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
452 newinode->i_uid = current_fsuid();
453 if (inode->i_mode & S_ISGID)
454 newinode->i_gid = inode->i_gid;
456 newinode->i_gid = current_fsgid();
461 cifs_create_set_dentry:
463 setup_cifs_dentry(tcon, direntry, newinode);
465 cFYI(1, "Create worked, get_inode_info failed rc = %d", rc);
467 if (newinode && nd && (nd->flags & LOOKUP_OPEN)) {
468 struct cifsFileInfo *pfile_info;
471 filp = lookup_instantiate_filp(nd, direntry, generic_file_open);
474 CIFSSMBClose(xid, tcon, fileHandle);
475 goto cifs_create_out;
478 pfile_info = cifs_new_fileinfo(newinode, fileHandle, filp,
479 nd->path.mnt, oflags);
480 if (pfile_info == NULL) {
482 CIFSSMBClose(xid, tcon, fileHandle);
486 CIFSSMBClose(xid, tcon, fileHandle);
496 int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
501 struct cifs_sb_info *cifs_sb;
502 struct cifsTconInfo *pTcon;
503 char *full_path = NULL;
504 struct inode *newinode = NULL;
506 if (!old_valid_dev(device_number))
511 cifs_sb = CIFS_SB(inode->i_sb);
512 pTcon = cifs_sb->tcon;
514 full_path = build_path_from_dentry(direntry);
515 if (full_path == NULL)
517 else 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);
538 rc = cifs_get_inode_info_unix(&newinode, full_path,
541 direntry->d_op = &cifs_ci_dentry_ops;
543 direntry->d_op = &cifs_dentry_ops;
545 d_instantiate(direntry, newinode);
548 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
553 cFYI(1, "sfu compat create special file");
555 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
563 rc = CIFSSMBOpen(xid, pTcon, full_path,
564 FILE_CREATE, /* fail if exists */
565 GENERIC_WRITE /* BB would
566 WRITE_OWNER | WRITE_DAC be better? */,
567 /* Create a file and set the
568 file attribute to SYSTEM */
569 CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,
570 &fileHandle, &oplock, buf,
572 cifs_sb->mnt_cifs_flags &
573 CIFS_MOUNT_MAP_SPECIAL_CHR);
575 /* BB FIXME - add handling for backlevel servers
576 which need legacy open and check for all
577 calls to SMBOpen for fallback to SMBLeagcyOpen */
579 /* BB Do not bother to decode buf since no
580 local inode yet to put timestamps in,
581 but we can reuse it safely */
582 unsigned int bytes_written;
583 struct win_dev *pdev;
584 pdev = (struct win_dev *)buf;
586 memcpy(pdev->type, "IntxCHR", 8);
588 cpu_to_le64(MAJOR(device_number));
590 cpu_to_le64(MINOR(device_number));
591 rc = CIFSSMBWrite(xid, pTcon,
593 sizeof(struct win_dev),
594 0, &bytes_written, (char *)pdev,
596 } else if (S_ISBLK(mode)) {
597 memcpy(pdev->type, "IntxBLK", 8);
599 cpu_to_le64(MAJOR(device_number));
601 cpu_to_le64(MINOR(device_number));
602 rc = CIFSSMBWrite(xid, pTcon,
604 sizeof(struct win_dev),
605 0, &bytes_written, (char *)pdev,
607 } /* else if(S_ISFIFO */
608 CIFSSMBClose(xid, pTcon, fileHandle);
612 /* add code here to set EAs */
622 cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
623 struct nameidata *nd)
626 int rc = 0; /* to get around spurious gcc warning, set to zero here */
628 __u16 fileHandle = 0;
629 bool posix_open = false;
630 struct cifs_sb_info *cifs_sb;
631 struct cifsTconInfo *pTcon;
632 struct cifsFileInfo *cfile;
633 struct inode *newInode = NULL;
634 char *full_path = NULL;
639 cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
640 parent_dir_inode, direntry->d_name.name, direntry);
642 /* check whether path exists */
644 cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
645 pTcon = cifs_sb->tcon;
648 * Don't allow the separator character in a path component.
649 * The VFS will not allow "/", but "\" is allowed by posix.
651 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
653 for (i = 0; i < direntry->d_name.len; i++)
654 if (direntry->d_name.name[i] == '\\') {
655 cFYI(1, "Invalid file name");
657 return ERR_PTR(-EINVAL);
662 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
663 * the VFS handle the create.
665 if (nd && (nd->flags & LOOKUP_EXCL)) {
666 d_instantiate(direntry, NULL);
670 /* can not grab the rename sem here since it would
671 deadlock in the cases (beginning of sys_rename itself)
672 in which we already have the sb rename sem */
673 full_path = build_path_from_dentry(direntry);
674 if (full_path == NULL) {
676 return ERR_PTR(-ENOMEM);
679 if (direntry->d_inode != NULL) {
680 cFYI(1, "non-NULL inode in lookup");
682 cFYI(1, "NULL inode in lookup");
684 cFYI(1, "Full path: %s inode = 0x%p", full_path, direntry->d_inode);
686 /* Posix open is only called (at lookup time) for file create now.
687 * For opens (rather than creates), because we do not know if it
688 * is a file or directory yet, and current Samba no longer allows
689 * us to do posix open on dirs, we could end up wasting an open call
690 * on what turns out to be a dir. For file opens, we wait to call posix
691 * open till cifs_open. It could be added here (lookup) in the future
692 * but the performance tradeoff of the extra network request when EISDIR
693 * or EACCES is returned would have to be weighed against the 50%
694 * reduction in network traffic in the other paths.
696 if (pTcon->unix_ext) {
697 if (nd && !(nd->flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY)) &&
698 (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
699 (nd->intent.open.flags & O_CREAT)) {
700 rc = cifs_posix_open(full_path, &newInode,
701 parent_dir_inode->i_sb,
702 nd->intent.open.create_mode,
703 nd->intent.open.flags, &oplock,
706 * The check below works around a bug in POSIX
707 * open in samba versions 3.3.1 and earlier where
708 * open could incorrectly fail with invalid parameter.
709 * If either that or op not supported returned, follow
712 if ((rc == 0) || (rc == -ENOENT))
714 else if ((rc == -EINVAL) || (rc != -EOPNOTSUPP))
715 pTcon->broken_posix_open = true;
718 rc = cifs_get_inode_info_unix(&newInode, full_path,
719 parent_dir_inode->i_sb, xid);
721 rc = cifs_get_inode_info(&newInode, full_path, NULL,
722 parent_dir_inode->i_sb, xid, NULL);
724 if ((rc == 0) && (newInode != NULL)) {
726 direntry->d_op = &cifs_ci_dentry_ops;
728 direntry->d_op = &cifs_dentry_ops;
729 d_add(direntry, newInode);
731 filp = lookup_instantiate_filp(nd, direntry,
735 CIFSSMBClose(xid, pTcon, fileHandle);
739 cfile = cifs_new_fileinfo(newInode, fileHandle, filp,
741 nd->intent.open.flags);
744 CIFSSMBClose(xid, pTcon, fileHandle);
749 /* since paths are not looked up by component - the parent
750 directories are presumed to be good here */
751 renew_parental_timestamps(direntry);
753 } else if (rc == -ENOENT) {
755 direntry->d_time = jiffies;
757 direntry->d_op = &cifs_ci_dentry_ops;
759 direntry->d_op = &cifs_dentry_ops;
760 d_add(direntry, NULL);
761 /* if it was once a directory (but how can we tell?) we could do
762 shrink_dcache_parent(direntry); */
763 } else if (rc != -EACCES) {
764 cERROR(1, "Unexpected lookup error %d", rc);
765 /* We special case check for Access Denied - since that
766 is a common return code */
776 cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
780 if (direntry->d_inode) {
781 if (cifs_revalidate_dentry(direntry))
784 cFYI(1, "neg dentry 0x%p name = %s",
785 direntry, direntry->d_name.name);
786 if (time_after(jiffies, direntry->d_time + HZ) ||
787 !lookupCacheEnabled) {
796 /* static int cifs_d_delete(struct dentry *direntry)
800 cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
805 const struct dentry_operations cifs_dentry_ops = {
806 .d_revalidate = cifs_d_revalidate,
807 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
810 static int cifs_ci_hash(struct dentry *dentry, struct qstr *q)
812 struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
816 hash = init_name_hash();
817 for (i = 0; i < q->len; i++)
818 hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
820 q->hash = end_name_hash(hash);
825 static int cifs_ci_compare(struct dentry *dentry, struct qstr *a,
828 struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
830 if ((a->len == b->len) &&
831 (nls_strnicmp(codepage, a->name, b->name, a->len) == 0)) {
833 * To preserve case, don't let an existing negative dentry's
834 * case take precedence. If a is not a negative dentry, this
835 * should have no side effects
837 memcpy((void *)a->name, b->name, a->len);
843 const struct dentry_operations cifs_ci_dentry_ops = {
844 .d_revalidate = cifs_d_revalidate,
845 .d_hash = cifs_ci_hash,
846 .d_compare = cifs_ci_compare,