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
)
146 pCifsFile
->netfid
= fileHandle
;
147 pCifsFile
->pid
= current
->tgid
;
148 pCifsFile
->pInode
= igrab(newinode
);
149 pCifsFile
->mnt
= mnt
;
150 pCifsFile
->pfile
= file
;
151 pCifsFile
->invalidHandle
= false;
152 pCifsFile
->closePend
= false;
153 mutex_init(&pCifsFile
->fh_mutex
);
154 mutex_init(&pCifsFile
->lock_mutex
);
155 INIT_LIST_HEAD(&pCifsFile
->llist
);
156 atomic_set(&pCifsFile
->count
, 1);
157 INIT_WORK(&pCifsFile
->oplock_break
, cifs_oplock_break
);
159 write_lock(&GlobalSMBSeslock
);
160 list_add(&pCifsFile
->tlist
, &cifs_sb
->tcon
->openFileList
);
161 pCifsInode
= CIFS_I(newinode
);
163 /* if readable file instance put first in list*/
164 if (oflags
& FMODE_READ
)
165 list_add(&pCifsFile
->flist
, &pCifsInode
->openFileList
);
167 list_add_tail(&pCifsFile
->flist
,
168 &pCifsInode
->openFileList
);
170 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
171 pCifsInode
->clientCanCacheAll
= true;
172 pCifsInode
->clientCanCacheRead
= true;
173 cFYI(1, "Exclusive Oplock inode %p", newinode
);
174 } else if ((oplock
& 0xF) == OPLOCK_READ
)
175 pCifsInode
->clientCanCacheRead
= true;
177 write_unlock(&GlobalSMBSeslock
);
179 file
->private_data
= pCifsFile
;
184 int cifs_posix_open(char *full_path
, struct inode
**pinode
,
185 struct super_block
*sb
, int mode
, int oflags
,
186 __u32
*poplock
, __u16
*pnetfid
, int xid
)
189 FILE_UNIX_BASIC_INFO
*presp_data
;
190 __u32 posix_flags
= 0;
191 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
192 struct cifs_fattr fattr
;
194 cFYI(1, "posix open %s", full_path
);
196 presp_data
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
197 if (presp_data
== NULL
)
200 /* So far cifs posix extensions can only map the following flags.
201 There are other valid fmode oflags such as FMODE_LSEEK, FMODE_PREAD, but
202 so far we do not seem to need them, and we can treat them as local only */
203 if ((oflags
& (FMODE_READ
| FMODE_WRITE
)) ==
204 (FMODE_READ
| FMODE_WRITE
))
205 posix_flags
= SMB_O_RDWR
;
206 else if (oflags
& FMODE_READ
)
207 posix_flags
= SMB_O_RDONLY
;
208 else if (oflags
& FMODE_WRITE
)
209 posix_flags
= SMB_O_WRONLY
;
210 if (oflags
& O_CREAT
)
211 posix_flags
|= SMB_O_CREAT
;
213 posix_flags
|= SMB_O_EXCL
;
214 if (oflags
& O_TRUNC
)
215 posix_flags
|= SMB_O_TRUNC
;
216 /* be safe and imply O_SYNC for O_DSYNC */
217 if (oflags
& O_DSYNC
)
218 posix_flags
|= SMB_O_SYNC
;
219 if (oflags
& O_DIRECTORY
)
220 posix_flags
|= SMB_O_DIRECTORY
;
221 if (oflags
& O_NOFOLLOW
)
222 posix_flags
|= SMB_O_NOFOLLOW
;
223 if (oflags
& O_DIRECT
)
224 posix_flags
|= SMB_O_DIRECT
;
226 mode
&= ~current_umask();
227 rc
= CIFSPOSIXCreate(xid
, cifs_sb
->tcon
, posix_flags
, mode
,
228 pnetfid
, presp_data
, poplock
, full_path
,
229 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
230 CIFS_MOUNT_MAP_SPECIAL_CHR
);
234 if (presp_data
->Type
== cpu_to_le32(-1))
235 goto posix_open_ret
; /* open ok, caller does qpathinfo */
238 goto posix_open_ret
; /* caller does not need info */
240 cifs_unix_basic_to_fattr(&fattr
, presp_data
, cifs_sb
);
242 /* get new inode and set it up */
243 if (*pinode
== NULL
) {
244 cifs_fill_uniqueid(sb
, &fattr
);
245 *pinode
= cifs_iget(sb
, &fattr
);
251 cifs_fattr_to_inode(*pinode
, &fattr
);
259 static void setup_cifs_dentry(struct cifsTconInfo
*tcon
,
260 struct dentry
*direntry
,
261 struct inode
*newinode
)
264 direntry
->d_op
= &cifs_ci_dentry_ops
;
266 direntry
->d_op
= &cifs_dentry_ops
;
267 d_instantiate(direntry
, newinode
);
270 /* Inode operations in similar order to how they appear in Linux file fs.h */
273 cifs_create(struct inode
*inode
, struct dentry
*direntry
, int mode
,
274 struct nameidata
*nd
)
278 int create_options
= CREATE_NOT_DIR
;
282 * BB below access is probably too much for mknod to request
283 * but we have to do query and setpathinfo so requesting
284 * less could fail (unless we want to request getatr and setatr
285 * permissions (only). At least for POSIX we do not have to
288 int desiredAccess
= GENERIC_READ
| GENERIC_WRITE
;
290 struct cifs_sb_info
*cifs_sb
;
291 struct cifsTconInfo
*tcon
;
292 char *full_path
= NULL
;
293 FILE_ALL_INFO
*buf
= NULL
;
294 struct inode
*newinode
= NULL
;
295 int disposition
= FILE_OVERWRITE_IF
;
299 cifs_sb
= CIFS_SB(inode
->i_sb
);
300 tcon
= cifs_sb
->tcon
;
302 full_path
= build_path_from_dentry(direntry
);
303 if (full_path
== NULL
) {
305 goto cifs_create_out
;
311 if (nd
&& (nd
->flags
& LOOKUP_OPEN
))
312 oflags
= nd
->intent
.open
.flags
;
314 oflags
= FMODE_READ
| SMB_O_CREAT
;
316 if (tcon
->unix_ext
&& (tcon
->ses
->capabilities
& CAP_UNIX
) &&
317 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
318 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
319 rc
= cifs_posix_open(full_path
, &newinode
,
320 inode
->i_sb
, mode
, oflags
, &oplock
, &fileHandle
, xid
);
321 /* EIO could indicate that (posix open) operation is not
322 supported, despite what server claimed in capability
323 negotation. EREMOTE indicates DFS junction, which is not
324 handled in posix open */
327 if (newinode
== NULL
) /* query inode info */
328 goto cifs_create_get_file_info
;
329 else /* success, no need to query */
330 goto cifs_create_set_dentry
;
331 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
332 (rc
!= -EOPNOTSUPP
) && (rc
!= -EINVAL
))
333 goto cifs_create_out
;
334 /* else fallthrough to retry, using older open call, this is
335 case where server does not support this SMB level, and
336 falsely claims capability (also get here for DFS case
337 which should be rare for path not covered on files) */
340 if (nd
&& (nd
->flags
& LOOKUP_OPEN
)) {
341 /* if the file is going to stay open, then we
342 need to set the desired access properly */
344 if (oflags
& FMODE_READ
)
345 desiredAccess
|= GENERIC_READ
; /* is this too little? */
346 if (oflags
& FMODE_WRITE
)
347 desiredAccess
|= GENERIC_WRITE
;
349 if ((oflags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
350 disposition
= FILE_CREATE
;
351 else if ((oflags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
352 disposition
= FILE_OVERWRITE_IF
;
353 else if ((oflags
& O_CREAT
) == O_CREAT
)
354 disposition
= FILE_OPEN_IF
;
356 cFYI(1, "Create flag not set in create function");
359 /* BB add processing to set equivalent of mode - e.g. via CreateX with
362 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
365 goto cifs_create_out
;
369 * if we're not using unix extensions, see if we need to set
370 * ATTR_READONLY on the create call
372 if (!tcon
->unix_ext
&& (mode
& S_IWUGO
) == 0)
373 create_options
|= CREATE_OPTION_READONLY
;
375 if (cifs_sb
->tcon
->ses
->capabilities
& CAP_NT_SMBS
)
376 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
,
377 desiredAccess
, create_options
,
378 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
379 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
381 rc
= -EIO
; /* no NT SMB support fall into legacy open below */
384 /* old server, retry the open legacy style */
385 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, disposition
,
386 desiredAccess
, create_options
,
387 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
388 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
391 cFYI(1, "cifs_create returned 0x%x", rc
);
392 goto cifs_create_out
;
395 /* If Open reported that we actually created a file
396 then we now have to set the mode if possible */
397 if ((tcon
->unix_ext
) && (oplock
& CIFS_CREATE_ACTION
)) {
398 struct cifs_unix_set_info_args args
= {
400 .ctime
= NO_CHANGE_64
,
401 .atime
= NO_CHANGE_64
,
402 .mtime
= NO_CHANGE_64
,
406 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
407 args
.uid
= (__u64
) current_fsuid();
408 if (inode
->i_mode
& S_ISGID
)
409 args
.gid
= (__u64
) inode
->i_gid
;
411 args
.gid
= (__u64
) current_fsgid();
413 args
.uid
= NO_CHANGE_64
;
414 args
.gid
= NO_CHANGE_64
;
416 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
418 cifs_sb
->mnt_cifs_flags
&
419 CIFS_MOUNT_MAP_SPECIAL_CHR
);
421 /* BB implement mode setting via Windows security
423 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
425 /* Could set r/o dos attribute if mode & 0222 == 0 */
428 cifs_create_get_file_info
:
429 /* server might mask mode so we have to query for it */
431 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
434 rc
= cifs_get_inode_info(&newinode
, full_path
, buf
,
435 inode
->i_sb
, xid
, &fileHandle
);
437 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
438 newinode
->i_mode
= mode
;
439 if ((oplock
& CIFS_CREATE_ACTION
) &&
440 (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
)) {
441 newinode
->i_uid
= current_fsuid();
442 if (inode
->i_mode
& S_ISGID
)
443 newinode
->i_gid
= inode
->i_gid
;
445 newinode
->i_gid
= current_fsgid();
450 cifs_create_set_dentry
:
452 setup_cifs_dentry(tcon
, direntry
, newinode
);
454 cFYI(1, "Create worked, get_inode_info failed rc = %d", rc
);
456 if (newinode
&& nd
&& (nd
->flags
& LOOKUP_OPEN
)) {
457 struct cifsFileInfo
*pfile_info
;
460 filp
= lookup_instantiate_filp(nd
, direntry
, generic_file_open
);
463 CIFSSMBClose(xid
, tcon
, fileHandle
);
464 goto cifs_create_out
;
467 pfile_info
= cifs_new_fileinfo(newinode
, fileHandle
, filp
,
468 nd
->path
.mnt
, oflags
, oplock
);
469 if (pfile_info
== NULL
) {
471 CIFSSMBClose(xid
, tcon
, fileHandle
);
475 CIFSSMBClose(xid
, tcon
, fileHandle
);
485 int cifs_mknod(struct inode
*inode
, struct dentry
*direntry
, int mode
,
490 struct cifs_sb_info
*cifs_sb
;
491 struct cifsTconInfo
*pTcon
;
492 char *full_path
= NULL
;
493 struct inode
*newinode
= NULL
;
496 FILE_ALL_INFO
*buf
= NULL
;
497 unsigned int bytes_written
;
498 struct win_dev
*pdev
;
500 if (!old_valid_dev(device_number
))
505 cifs_sb
= CIFS_SB(inode
->i_sb
);
506 pTcon
= cifs_sb
->tcon
;
508 full_path
= build_path_from_dentry(direntry
);
509 if (full_path
== NULL
) {
514 if (pTcon
->unix_ext
) {
515 struct cifs_unix_set_info_args args
= {
516 .mode
= mode
& ~current_umask(),
517 .ctime
= NO_CHANGE_64
,
518 .atime
= NO_CHANGE_64
,
519 .mtime
= NO_CHANGE_64
,
520 .device
= device_number
,
522 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
523 args
.uid
= (__u64
) current_fsuid();
524 args
.gid
= (__u64
) current_fsgid();
526 args
.uid
= NO_CHANGE_64
;
527 args
.gid
= NO_CHANGE_64
;
529 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, &args
,
531 cifs_sb
->mnt_cifs_flags
&
532 CIFS_MOUNT_MAP_SPECIAL_CHR
);
536 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
539 direntry
->d_op
= &cifs_ci_dentry_ops
;
541 direntry
->d_op
= &cifs_dentry_ops
;
544 d_instantiate(direntry
, newinode
);
548 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
))
552 cFYI(1, "sfu compat create special file");
554 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
562 rc
= CIFSSMBOpen(xid
, pTcon
, full_path
, FILE_CREATE
,
563 GENERIC_WRITE
, CREATE_NOT_DIR
| CREATE_OPTION_SPECIAL
,
564 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
565 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
569 /* BB Do not bother to decode buf since no local inode yet to put
570 * timestamps in, but we can reuse it safely */
572 pdev
= (struct win_dev
*)buf
;
574 memcpy(pdev
->type
, "IntxCHR", 8);
576 cpu_to_le64(MAJOR(device_number
));
578 cpu_to_le64(MINOR(device_number
));
579 rc
= CIFSSMBWrite(xid
, pTcon
,
581 sizeof(struct win_dev
),
582 0, &bytes_written
, (char *)pdev
,
584 } else if (S_ISBLK(mode
)) {
585 memcpy(pdev
->type
, "IntxBLK", 8);
587 cpu_to_le64(MAJOR(device_number
));
589 cpu_to_le64(MINOR(device_number
));
590 rc
= CIFSSMBWrite(xid
, pTcon
,
592 sizeof(struct win_dev
),
593 0, &bytes_written
, (char *)pdev
,
595 } /* else if (S_ISFIFO) */
596 CIFSSMBClose(xid
, pTcon
, fileHandle
);
608 cifs_lookup(struct inode
*parent_dir_inode
, struct dentry
*direntry
,
609 struct nameidata
*nd
)
612 int rc
= 0; /* to get around spurious gcc warning, set to zero here */
614 __u16 fileHandle
= 0;
615 bool posix_open
= false;
616 struct cifs_sb_info
*cifs_sb
;
617 struct cifsTconInfo
*pTcon
;
618 struct cifsFileInfo
*cfile
;
619 struct inode
*newInode
= NULL
;
620 char *full_path
= NULL
;
625 cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
626 parent_dir_inode
, direntry
->d_name
.name
, direntry
);
628 /* check whether path exists */
630 cifs_sb
= CIFS_SB(parent_dir_inode
->i_sb
);
631 pTcon
= cifs_sb
->tcon
;
634 * Don't allow the separator character in a path component.
635 * The VFS will not allow "/", but "\" is allowed by posix.
637 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
)) {
639 for (i
= 0; i
< direntry
->d_name
.len
; i
++)
640 if (direntry
->d_name
.name
[i
] == '\\') {
641 cFYI(1, "Invalid file name");
643 return ERR_PTR(-EINVAL
);
648 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
649 * the VFS handle the create.
651 if (nd
&& (nd
->flags
& LOOKUP_EXCL
)) {
652 d_instantiate(direntry
, NULL
);
656 /* can not grab the rename sem here since it would
657 deadlock in the cases (beginning of sys_rename itself)
658 in which we already have the sb rename sem */
659 full_path
= build_path_from_dentry(direntry
);
660 if (full_path
== NULL
) {
662 return ERR_PTR(-ENOMEM
);
665 if (direntry
->d_inode
!= NULL
) {
666 cFYI(1, "non-NULL inode in lookup");
668 cFYI(1, "NULL inode in lookup");
670 cFYI(1, "Full path: %s inode = 0x%p", full_path
, direntry
->d_inode
);
672 /* Posix open is only called (at lookup time) for file create now.
673 * For opens (rather than creates), because we do not know if it
674 * is a file or directory yet, and current Samba no longer allows
675 * us to do posix open on dirs, we could end up wasting an open call
676 * on what turns out to be a dir. For file opens, we wait to call posix
677 * open till cifs_open. It could be added here (lookup) in the future
678 * but the performance tradeoff of the extra network request when EISDIR
679 * or EACCES is returned would have to be weighed against the 50%
680 * reduction in network traffic in the other paths.
682 if (pTcon
->unix_ext
) {
683 if (nd
&& !(nd
->flags
& (LOOKUP_PARENT
| LOOKUP_DIRECTORY
)) &&
684 (nd
->flags
& LOOKUP_OPEN
) && !pTcon
->broken_posix_open
&&
685 (nd
->intent
.open
.flags
& O_CREAT
)) {
686 rc
= cifs_posix_open(full_path
, &newInode
,
687 parent_dir_inode
->i_sb
,
688 nd
->intent
.open
.create_mode
,
689 nd
->intent
.open
.flags
, &oplock
,
692 * The check below works around a bug in POSIX
693 * open in samba versions 3.3.1 and earlier where
694 * open could incorrectly fail with invalid parameter.
695 * If either that or op not supported returned, follow
698 if ((rc
== 0) || (rc
== -ENOENT
))
700 else if ((rc
== -EINVAL
) || (rc
!= -EOPNOTSUPP
))
701 pTcon
->broken_posix_open
= true;
704 rc
= cifs_get_inode_info_unix(&newInode
, full_path
,
705 parent_dir_inode
->i_sb
, xid
);
707 rc
= cifs_get_inode_info(&newInode
, full_path
, NULL
,
708 parent_dir_inode
->i_sb
, xid
, NULL
);
710 if ((rc
== 0) && (newInode
!= NULL
)) {
712 direntry
->d_op
= &cifs_ci_dentry_ops
;
714 direntry
->d_op
= &cifs_dentry_ops
;
715 d_add(direntry
, newInode
);
717 filp
= lookup_instantiate_filp(nd
, direntry
,
721 CIFSSMBClose(xid
, pTcon
, fileHandle
);
725 cfile
= cifs_new_fileinfo(newInode
, fileHandle
, filp
,
727 nd
->intent
.open
.flags
,
731 CIFSSMBClose(xid
, pTcon
, fileHandle
);
736 /* since paths are not looked up by component - the parent
737 directories are presumed to be good here */
738 renew_parental_timestamps(direntry
);
740 } else if (rc
== -ENOENT
) {
742 direntry
->d_time
= jiffies
;
744 direntry
->d_op
= &cifs_ci_dentry_ops
;
746 direntry
->d_op
= &cifs_dentry_ops
;
747 d_add(direntry
, NULL
);
748 /* if it was once a directory (but how can we tell?) we could do
749 shrink_dcache_parent(direntry); */
750 } else if (rc
!= -EACCES
) {
751 cERROR(1, "Unexpected lookup error %d", rc
);
752 /* We special case check for Access Denied - since that
753 is a common return code */
763 cifs_d_revalidate(struct dentry
*direntry
, struct nameidata
*nd
)
767 if (direntry
->d_inode
) {
768 if (cifs_revalidate_dentry(direntry
))
771 cFYI(1, "neg dentry 0x%p name = %s",
772 direntry
, direntry
->d_name
.name
);
773 if (time_after(jiffies
, direntry
->d_time
+ HZ
) ||
774 !lookupCacheEnabled
) {
783 /* static int cifs_d_delete(struct dentry *direntry)
787 cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
792 const struct dentry_operations cifs_dentry_ops
= {
793 .d_revalidate
= cifs_d_revalidate
,
794 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
797 static int cifs_ci_hash(struct dentry
*dentry
, struct qstr
*q
)
799 struct nls_table
*codepage
= CIFS_SB(dentry
->d_inode
->i_sb
)->local_nls
;
803 hash
= init_name_hash();
804 for (i
= 0; i
< q
->len
; i
++)
805 hash
= partial_name_hash(nls_tolower(codepage
, q
->name
[i
]),
807 q
->hash
= end_name_hash(hash
);
812 static int cifs_ci_compare(struct dentry
*dentry
, struct qstr
*a
,
815 struct nls_table
*codepage
= CIFS_SB(dentry
->d_inode
->i_sb
)->local_nls
;
817 if ((a
->len
== b
->len
) &&
818 (nls_strnicmp(codepage
, a
->name
, b
->name
, a
->len
) == 0)) {
820 * To preserve case, don't let an existing negative dentry's
821 * case take precedence. If a is not a negative dentry, this
822 * should have no side effects
824 memcpy((void *)a
->name
, b
->name
, a
->len
);
830 const struct dentry_operations cifs_ci_dentry_ops
= {
831 .d_revalidate
= cifs_d_revalidate
,
832 .d_hash
= cifs_ci_hash
,
833 .d_compare
= cifs_ci_compare
,