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>
31 #include "cifsproto.h"
32 #include "cifs_debug.h"
33 #include "cifs_fs_sb.h"
36 renew_parental_timestamps(struct dentry
*direntry
)
38 /* BB check if there is a way to get the kernel to do this or if we
41 direntry
->d_time
= jiffies
;
42 direntry
= direntry
->d_parent
;
43 } while (!IS_ROOT(direntry
));
46 /* Note: caller must free return buffer */
48 build_path_from_dentry(struct dentry
*direntry
)
56 struct cifs_sb_info
*cifs_sb
;
59 return NULL
; /* not much we can do if dentry is freed and
60 we need to reopen the file after it was closed implicitly
61 when the server crashed */
63 cifs_sb
= CIFS_SB(direntry
->d_sb
);
64 dirsep
= CIFS_DIR_SEP(cifs_sb
);
65 pplen
= cifs_sb
->prepathlen
;
66 if (cifs_sb
->tcon
&& (cifs_sb
->tcon
->Flags
& SMB_SHARE_IS_IN_DFS
))
67 dfsplen
= strnlen(cifs_sb
->tcon
->treeName
, MAX_TREE_SIZE
+ 1);
71 namelen
= pplen
+ dfsplen
;
72 for (temp
= direntry
; !IS_ROOT(temp
);) {
73 namelen
+= (1 + temp
->d_name
.len
);
74 temp
= temp
->d_parent
;
76 cERROR(1, ("corrupt dentry"));
81 full_path
= kmalloc(namelen
+1, GFP_KERNEL
);
82 if (full_path
== NULL
)
84 full_path
[namelen
] = 0; /* trailing null */
85 for (temp
= direntry
; !IS_ROOT(temp
);) {
86 namelen
-= 1 + temp
->d_name
.len
;
90 full_path
[namelen
] = dirsep
;
91 strncpy(full_path
+ namelen
+ 1, temp
->d_name
.name
,
93 cFYI(0, ("name: %s", full_path
+ namelen
));
95 temp
= temp
->d_parent
;
97 cERROR(1, ("corrupt dentry"));
102 if (namelen
!= pplen
+ dfsplen
) {
104 ("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 slow_work_init(&pCifsFile
->oplock_break
, &cifs_oplock_break_ops
);
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
);
185 int cifs_posix_open(char *full_path
, struct inode
**pinode
,
186 struct vfsmount
*mnt
, struct super_block
*sb
,
187 int mode
, int oflags
,
188 __u32
*poplock
, __u16
*pnetfid
, int xid
)
191 FILE_UNIX_BASIC_INFO
*presp_data
;
192 __u32 posix_flags
= 0;
193 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
194 struct cifs_fattr fattr
;
196 cFYI(1, ("posix open %s", full_path
));
198 presp_data
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
199 if (presp_data
== NULL
)
202 /* So far cifs posix extensions can only map the following flags.
203 There are other valid fmode oflags such as FMODE_LSEEK, FMODE_PREAD, but
204 so far we do not seem to need them, and we can treat them as local only */
205 if ((oflags
& (FMODE_READ
| FMODE_WRITE
)) ==
206 (FMODE_READ
| FMODE_WRITE
))
207 posix_flags
= SMB_O_RDWR
;
208 else if (oflags
& FMODE_READ
)
209 posix_flags
= SMB_O_RDONLY
;
210 else if (oflags
& FMODE_WRITE
)
211 posix_flags
= SMB_O_WRONLY
;
212 if (oflags
& O_CREAT
)
213 posix_flags
|= SMB_O_CREAT
;
215 posix_flags
|= SMB_O_EXCL
;
216 if (oflags
& O_TRUNC
)
217 posix_flags
|= SMB_O_TRUNC
;
219 posix_flags
|= SMB_O_SYNC
;
220 if (oflags
& O_DIRECTORY
)
221 posix_flags
|= SMB_O_DIRECTORY
;
222 if (oflags
& O_NOFOLLOW
)
223 posix_flags
|= SMB_O_NOFOLLOW
;
224 if (oflags
& O_DIRECT
)
225 posix_flags
|= SMB_O_DIRECT
;
227 mode
&= ~current_umask();
228 rc
= CIFSPOSIXCreate(xid
, cifs_sb
->tcon
, posix_flags
, mode
,
229 pnetfid
, presp_data
, poplock
, 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
);
255 cifs_new_fileinfo(*pinode
, *pnetfid
, NULL
, mnt
, oflags
);
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
;
284 bool posix_create
= false;
286 * BB below access is probably too much for mknod to request
287 * but we have to do query and setpathinfo so requesting
288 * less could fail (unless we want to request getatr and setatr
289 * permissions (only). At least for POSIX we do not have to
292 int desiredAccess
= GENERIC_READ
| GENERIC_WRITE
;
294 struct cifs_sb_info
*cifs_sb
;
295 struct cifsTconInfo
*tcon
;
296 char *full_path
= NULL
;
297 FILE_ALL_INFO
*buf
= NULL
;
298 struct inode
*newinode
= NULL
;
299 int disposition
= FILE_OVERWRITE_IF
;
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
;
319 oflags
= FMODE_READ
| SMB_O_CREAT
;
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
,
325 nd
? nd
->path
.mnt
: NULL
,
326 inode
->i_sb
, mode
, oflags
, &oplock
, &fileHandle
, xid
);
327 /* EIO could indicate that (posix open) operation is not
328 supported, despite what server claimed in capability
329 negotation. EREMOTE indicates DFS junction, which is not
330 handled in posix open */
334 if (newinode
== NULL
) /* query inode info */
335 goto cifs_create_get_file_info
;
336 else /* success, no need to query */
337 goto cifs_create_set_dentry
;
338 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
339 (rc
!= -EOPNOTSUPP
) && (rc
!= -EINVAL
))
340 goto cifs_create_out
;
341 /* else fallthrough to retry, using older open call, this is
342 case where server does not support this SMB level, and
343 falsely claims capability (also get here for DFS case
344 which should be rare for path not covered on files) */
347 if (nd
&& (nd
->flags
& LOOKUP_OPEN
)) {
348 /* if the file is going to stay open, then we
349 need to set the desired access properly */
351 if (oflags
& FMODE_READ
)
352 desiredAccess
|= GENERIC_READ
; /* is this too little? */
353 if (oflags
& FMODE_WRITE
)
354 desiredAccess
|= GENERIC_WRITE
;
356 if ((oflags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
357 disposition
= FILE_CREATE
;
358 else if ((oflags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
359 disposition
= FILE_OVERWRITE_IF
;
360 else if ((oflags
& O_CREAT
) == O_CREAT
)
361 disposition
= FILE_OPEN_IF
;
363 cFYI(1, ("Create flag not set in create function"));
366 /* BB add processing to set equivalent of mode - e.g. via CreateX with
369 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
377 * if we're not using unix extensions, see if we need to set
378 * ATTR_READONLY on the create call
380 if (!tcon
->unix_ext
&& (mode
& S_IWUGO
) == 0)
381 create_options
|= CREATE_OPTION_READONLY
;
383 if (cifs_sb
->tcon
->ses
->capabilities
& CAP_NT_SMBS
)
384 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
,
385 desiredAccess
, create_options
,
386 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
387 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
389 rc
= -EIO
; /* no NT SMB support fall into legacy open below */
392 /* old server, retry the open legacy style */
393 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, disposition
,
394 desiredAccess
, create_options
,
395 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
396 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
399 cFYI(1, ("cifs_create returned 0x%x", rc
));
400 goto cifs_create_out
;
403 /* If Open reported that we actually created a file
404 then we now have to set the mode if possible */
405 if ((tcon
->unix_ext
) && (oplock
& CIFS_CREATE_ACTION
)) {
406 struct cifs_unix_set_info_args args
= {
408 .ctime
= NO_CHANGE_64
,
409 .atime
= NO_CHANGE_64
,
410 .mtime
= NO_CHANGE_64
,
414 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
415 args
.uid
= (__u64
) current_fsuid();
416 if (inode
->i_mode
& S_ISGID
)
417 args
.gid
= (__u64
) inode
->i_gid
;
419 args
.gid
= (__u64
) current_fsgid();
421 args
.uid
= NO_CHANGE_64
;
422 args
.gid
= NO_CHANGE_64
;
424 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
426 cifs_sb
->mnt_cifs_flags
&
427 CIFS_MOUNT_MAP_SPECIAL_CHR
);
429 /* BB implement mode setting via Windows security
431 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
433 /* Could set r/o dos attribute if mode & 0222 == 0 */
436 cifs_create_get_file_info
:
437 /* server might mask mode so we have to query for it */
439 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
442 rc
= cifs_get_inode_info(&newinode
, full_path
, buf
,
443 inode
->i_sb
, xid
, &fileHandle
);
445 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
446 newinode
->i_mode
= mode
;
447 if ((oplock
& CIFS_CREATE_ACTION
) &&
448 (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
)) {
449 newinode
->i_uid
= current_fsuid();
450 if (inode
->i_mode
& S_ISGID
)
451 newinode
->i_gid
= inode
->i_gid
;
453 newinode
->i_gid
= current_fsgid();
458 cifs_create_set_dentry
:
460 setup_cifs_dentry(tcon
, direntry
, newinode
);
462 cFYI(1, ("Create worked, get_inode_info failed rc = %d", rc
));
464 /* nfsd case - nfs srv does not set nd */
465 if ((nd
== NULL
) || (!(nd
->flags
& LOOKUP_OPEN
))) {
466 /* mknod case - do not leave file open */
467 CIFSSMBClose(xid
, tcon
, fileHandle
);
468 } else if (!(posix_create
) && (newinode
)) {
469 cifs_new_fileinfo(newinode
, fileHandle
, NULL
,
470 nd
->path
.mnt
, oflags
);
479 int cifs_mknod(struct inode
*inode
, struct dentry
*direntry
, int mode
,
484 struct cifs_sb_info
*cifs_sb
;
485 struct cifsTconInfo
*pTcon
;
486 char *full_path
= NULL
;
487 struct inode
*newinode
= NULL
;
489 if (!old_valid_dev(device_number
))
494 cifs_sb
= CIFS_SB(inode
->i_sb
);
495 pTcon
= cifs_sb
->tcon
;
497 full_path
= build_path_from_dentry(direntry
);
498 if (full_path
== NULL
)
500 else if (pTcon
->unix_ext
) {
501 struct cifs_unix_set_info_args args
= {
502 .mode
= mode
& ~current_umask(),
503 .ctime
= NO_CHANGE_64
,
504 .atime
= NO_CHANGE_64
,
505 .mtime
= NO_CHANGE_64
,
506 .device
= device_number
,
508 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
509 args
.uid
= (__u64
) current_fsuid();
510 args
.gid
= (__u64
) current_fsgid();
512 args
.uid
= NO_CHANGE_64
;
513 args
.gid
= NO_CHANGE_64
;
515 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, &args
,
517 cifs_sb
->mnt_cifs_flags
&
518 CIFS_MOUNT_MAP_SPECIAL_CHR
);
521 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
524 direntry
->d_op
= &cifs_ci_dentry_ops
;
526 direntry
->d_op
= &cifs_dentry_ops
;
528 d_instantiate(direntry
, newinode
);
531 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
) {
536 cFYI(1, ("sfu compat create special file"));
538 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
546 rc
= CIFSSMBOpen(xid
, pTcon
, full_path
,
547 FILE_CREATE
, /* fail if exists */
548 GENERIC_WRITE
/* BB would
549 WRITE_OWNER | WRITE_DAC be better? */,
550 /* Create a file and set the
551 file attribute to SYSTEM */
552 CREATE_NOT_DIR
| CREATE_OPTION_SPECIAL
,
553 &fileHandle
, &oplock
, buf
,
555 cifs_sb
->mnt_cifs_flags
&
556 CIFS_MOUNT_MAP_SPECIAL_CHR
);
558 /* BB FIXME - add handling for backlevel servers
559 which need legacy open and check for all
560 calls to SMBOpen for fallback to SMBLeagcyOpen */
562 /* BB Do not bother to decode buf since no
563 local inode yet to put timestamps in,
564 but we can reuse it safely */
565 unsigned int bytes_written
;
566 struct win_dev
*pdev
;
567 pdev
= (struct win_dev
*)buf
;
569 memcpy(pdev
->type
, "IntxCHR", 8);
571 cpu_to_le64(MAJOR(device_number
));
573 cpu_to_le64(MINOR(device_number
));
574 rc
= CIFSSMBWrite(xid
, pTcon
,
576 sizeof(struct win_dev
),
577 0, &bytes_written
, (char *)pdev
,
579 } else if (S_ISBLK(mode
)) {
580 memcpy(pdev
->type
, "IntxBLK", 8);
582 cpu_to_le64(MAJOR(device_number
));
584 cpu_to_le64(MINOR(device_number
));
585 rc
= CIFSSMBWrite(xid
, pTcon
,
587 sizeof(struct win_dev
),
588 0, &bytes_written
, (char *)pdev
,
590 } /* else if(S_ISFIFO */
591 CIFSSMBClose(xid
, pTcon
, fileHandle
);
595 /* add code here to set EAs */
605 cifs_lookup(struct inode
*parent_dir_inode
, struct dentry
*direntry
,
606 struct nameidata
*nd
)
609 int rc
= 0; /* to get around spurious gcc warning, set to zero here */
611 __u16 fileHandle
= 0;
612 bool posix_open
= false;
613 struct cifs_sb_info
*cifs_sb
;
614 struct cifsTconInfo
*pTcon
;
615 struct inode
*newInode
= NULL
;
616 char *full_path
= NULL
;
621 cFYI(1, ("parent inode = 0x%p name is: %s and dentry = 0x%p",
622 parent_dir_inode
, direntry
->d_name
.name
, direntry
));
624 /* check whether path exists */
626 cifs_sb
= CIFS_SB(parent_dir_inode
->i_sb
);
627 pTcon
= cifs_sb
->tcon
;
630 * Don't allow the separator character in a path component.
631 * The VFS will not allow "/", but "\" is allowed by posix.
633 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
)) {
635 for (i
= 0; i
< direntry
->d_name
.len
; i
++)
636 if (direntry
->d_name
.name
[i
] == '\\') {
637 cFYI(1, ("Invalid file name"));
639 return ERR_PTR(-EINVAL
);
644 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
645 * the VFS handle the create.
647 if (nd
&& (nd
->flags
& LOOKUP_EXCL
)) {
648 d_instantiate(direntry
, NULL
);
652 /* can not grab the rename sem here since it would
653 deadlock in the cases (beginning of sys_rename itself)
654 in which we already have the sb rename sem */
655 full_path
= build_path_from_dentry(direntry
);
656 if (full_path
== NULL
) {
658 return ERR_PTR(-ENOMEM
);
661 if (direntry
->d_inode
!= NULL
) {
662 cFYI(1, ("non-NULL inode in lookup"));
664 cFYI(1, ("NULL inode in lookup"));
666 cFYI(1, ("Full path: %s inode = 0x%p", full_path
, direntry
->d_inode
));
668 /* Posix open is only called (at lookup time) for file create now.
669 * For opens (rather than creates), because we do not know if it
670 * is a file or directory yet, and current Samba no longer allows
671 * us to do posix open on dirs, we could end up wasting an open call
672 * on what turns out to be a dir. For file opens, we wait to call posix
673 * open till cifs_open. It could be added here (lookup) in the future
674 * but the performance tradeoff of the extra network request when EISDIR
675 * or EACCES is returned would have to be weighed against the 50%
676 * reduction in network traffic in the other paths.
678 if (pTcon
->unix_ext
) {
679 if (nd
&& !(nd
->flags
& (LOOKUP_PARENT
| LOOKUP_DIRECTORY
)) &&
680 (nd
->flags
& LOOKUP_OPEN
) && !pTcon
->broken_posix_open
&&
681 (nd
->intent
.open
.flags
& O_CREAT
)) {
682 rc
= cifs_posix_open(full_path
, &newInode
, nd
->path
.mnt
,
683 parent_dir_inode
->i_sb
,
684 nd
->intent
.open
.create_mode
,
685 nd
->intent
.open
.flags
, &oplock
,
688 * The check below works around a bug in POSIX
689 * open in samba versions 3.3.1 and earlier where
690 * open could incorrectly fail with invalid parameter.
691 * If either that or op not supported returned, follow
694 if ((rc
== 0) || (rc
== -ENOENT
))
696 else if ((rc
== -EINVAL
) || (rc
!= -EOPNOTSUPP
))
697 pTcon
->broken_posix_open
= true;
700 rc
= cifs_get_inode_info_unix(&newInode
, full_path
,
701 parent_dir_inode
->i_sb
, xid
);
703 rc
= cifs_get_inode_info(&newInode
, full_path
, NULL
,
704 parent_dir_inode
->i_sb
, xid
, NULL
);
706 if ((rc
== 0) && (newInode
!= NULL
)) {
708 direntry
->d_op
= &cifs_ci_dentry_ops
;
710 direntry
->d_op
= &cifs_dentry_ops
;
711 d_add(direntry
, newInode
);
713 filp
= lookup_instantiate_filp(nd
, direntry
, NULL
);
714 /* since paths are not looked up by component - the parent
715 directories are presumed to be good here */
716 renew_parental_timestamps(direntry
);
718 } else if (rc
== -ENOENT
) {
720 direntry
->d_time
= jiffies
;
722 direntry
->d_op
= &cifs_ci_dentry_ops
;
724 direntry
->d_op
= &cifs_dentry_ops
;
725 d_add(direntry
, NULL
);
726 /* if it was once a directory (but how can we tell?) we could do
727 shrink_dcache_parent(direntry); */
728 } else if (rc
!= -EACCES
) {
729 cERROR(1, ("Unexpected lookup error %d", rc
));
730 /* We special case check for Access Denied - since that
731 is a common return code */
740 cifs_d_revalidate(struct dentry
*direntry
, struct nameidata
*nd
)
744 if (direntry
->d_inode
) {
745 if (cifs_revalidate(direntry
))
748 cFYI(1, ("neg dentry 0x%p name = %s",
749 direntry
, direntry
->d_name
.name
));
750 if (time_after(jiffies
, direntry
->d_time
+ HZ
) ||
751 !lookupCacheEnabled
) {
760 /* static int cifs_d_delete(struct dentry *direntry)
764 cFYI(1, ("In cifs d_delete, name = %s", direntry->d_name.name));
769 const struct dentry_operations cifs_dentry_ops
= {
770 .d_revalidate
= cifs_d_revalidate
,
771 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
774 static int cifs_ci_hash(struct dentry
*dentry
, struct qstr
*q
)
776 struct nls_table
*codepage
= CIFS_SB(dentry
->d_inode
->i_sb
)->local_nls
;
780 hash
= init_name_hash();
781 for (i
= 0; i
< q
->len
; i
++)
782 hash
= partial_name_hash(nls_tolower(codepage
, q
->name
[i
]),
784 q
->hash
= end_name_hash(hash
);
789 static int cifs_ci_compare(struct dentry
*dentry
, struct qstr
*a
,
792 struct nls_table
*codepage
= CIFS_SB(dentry
->d_inode
->i_sb
)->local_nls
;
794 if ((a
->len
== b
->len
) &&
795 (nls_strnicmp(codepage
, a
->name
, b
->name
, a
->len
) == 0)) {
797 * To preserve case, don't let an existing negative dentry's
798 * case take precedence. If a is not a negative dentry, this
799 * should have no side effects
801 memcpy((void *)a
->name
, b
->name
, a
->len
);
807 const struct dentry_operations cifs_ci_dentry_ops
= {
808 .d_revalidate
= cifs_d_revalidate
,
809 .d_hash
= cifs_ci_hash
,
810 .d_compare
= cifs_ci_compare
,