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
) && (cifs_sb_tcon(cifs_sb
)->Flags
& SMB_SHARE_IS_IN_DFS
))
68 dfsplen
= strnlen(cifs_sb_tcon(cifs_sb
)->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(cifs_sb
)->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 pCifsFile
->tcon
= cifs_sb_tcon(cifs_sb
);
154 mutex_init(&pCifsFile
->fh_mutex
);
155 mutex_init(&pCifsFile
->lock_mutex
);
156 INIT_LIST_HEAD(&pCifsFile
->llist
);
157 atomic_set(&pCifsFile
->count
, 1);
158 INIT_WORK(&pCifsFile
->oplock_break
, cifs_oplock_break
);
160 write_lock(&GlobalSMBSeslock
);
161 list_add(&pCifsFile
->tlist
, &cifs_sb_tcon(cifs_sb
)->openFileList
);
162 pCifsInode
= CIFS_I(newinode
);
164 /* if readable file instance put first in list*/
165 if (oflags
& FMODE_READ
)
166 list_add(&pCifsFile
->flist
, &pCifsInode
->openFileList
);
168 list_add_tail(&pCifsFile
->flist
,
169 &pCifsInode
->openFileList
);
171 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
172 pCifsInode
->clientCanCacheAll
= true;
173 pCifsInode
->clientCanCacheRead
= true;
174 cFYI(1, "Exclusive Oplock inode %p", newinode
);
175 } else if ((oplock
& 0xF) == OPLOCK_READ
)
176 pCifsInode
->clientCanCacheRead
= true;
178 write_unlock(&GlobalSMBSeslock
);
180 file
->private_data
= pCifsFile
;
185 int cifs_posix_open(char *full_path
, struct inode
**pinode
,
186 struct super_block
*sb
, int mode
, int oflags
,
187 __u32
*poplock
, __u16
*pnetfid
, int xid
)
190 FILE_UNIX_BASIC_INFO
*presp_data
;
191 __u32 posix_flags
= 0;
192 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
193 struct cifs_fattr fattr
;
195 cFYI(1, "posix open %s", full_path
);
197 presp_data
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
198 if (presp_data
== NULL
)
201 /* So far cifs posix extensions can only map the following flags.
202 There are other valid fmode oflags such as FMODE_LSEEK, FMODE_PREAD, but
203 so far we do not seem to need them, and we can treat them as local only */
204 if ((oflags
& (FMODE_READ
| FMODE_WRITE
)) ==
205 (FMODE_READ
| FMODE_WRITE
))
206 posix_flags
= SMB_O_RDWR
;
207 else if (oflags
& FMODE_READ
)
208 posix_flags
= SMB_O_RDONLY
;
209 else if (oflags
& FMODE_WRITE
)
210 posix_flags
= SMB_O_WRONLY
;
211 if (oflags
& O_CREAT
)
212 posix_flags
|= SMB_O_CREAT
;
214 posix_flags
|= SMB_O_EXCL
;
215 if (oflags
& O_TRUNC
)
216 posix_flags
|= SMB_O_TRUNC
;
217 /* be safe and imply O_SYNC for O_DSYNC */
218 if (oflags
& O_DSYNC
)
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(cifs_sb
), 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 cifs_fill_uniqueid(sb
, &fattr
);
246 *pinode
= cifs_iget(sb
, &fattr
);
252 cifs_fattr_to_inode(*pinode
, &fattr
);
260 static void setup_cifs_dentry(struct cifsTconInfo
*tcon
,
261 struct dentry
*direntry
,
262 struct inode
*newinode
)
265 direntry
->d_op
= &cifs_ci_dentry_ops
;
267 direntry
->d_op
= &cifs_dentry_ops
;
268 d_instantiate(direntry
, newinode
);
271 /* Inode operations in similar order to how they appear in Linux file fs.h */
274 cifs_create(struct inode
*inode
, struct dentry
*direntry
, int mode
,
275 struct nameidata
*nd
)
279 int create_options
= CREATE_NOT_DIR
;
283 * BB below access is probably too much for mknod to request
284 * but we have to do query and setpathinfo so requesting
285 * less could fail (unless we want to request getatr and setatr
286 * permissions (only). At least for POSIX we do not have to
289 int desiredAccess
= GENERIC_READ
| GENERIC_WRITE
;
291 struct cifs_sb_info
*cifs_sb
;
292 struct cifsTconInfo
*tcon
;
293 char *full_path
= NULL
;
294 FILE_ALL_INFO
*buf
= NULL
;
295 struct inode
*newinode
= NULL
;
296 int disposition
= FILE_OVERWRITE_IF
;
300 cifs_sb
= CIFS_SB(inode
->i_sb
);
301 tcon
= cifs_sb_tcon(cifs_sb
);
303 full_path
= build_path_from_dentry(direntry
);
304 if (full_path
== NULL
) {
306 goto cifs_create_out
;
312 if (nd
&& (nd
->flags
& LOOKUP_OPEN
))
313 oflags
= nd
->intent
.open
.flags
;
315 oflags
= FMODE_READ
| SMB_O_CREAT
;
317 if (tcon
->unix_ext
&& (tcon
->ses
->capabilities
& CAP_UNIX
) &&
318 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
319 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
320 rc
= cifs_posix_open(full_path
, &newinode
,
321 inode
->i_sb
, mode
, oflags
, &oplock
, &fileHandle
, xid
);
322 /* EIO could indicate that (posix open) operation is not
323 supported, despite what server claimed in capability
324 negotation. EREMOTE indicates DFS junction, which is not
325 handled in posix open */
328 if (newinode
== NULL
) /* query inode info */
329 goto cifs_create_get_file_info
;
330 else /* success, no need to query */
331 goto cifs_create_set_dentry
;
332 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
333 (rc
!= -EOPNOTSUPP
) && (rc
!= -EINVAL
))
334 goto cifs_create_out
;
335 /* else fallthrough to retry, using older open call, this is
336 case where server does not support this SMB level, and
337 falsely claims capability (also get here for DFS case
338 which should be rare for path not covered on files) */
341 if (nd
&& (nd
->flags
& LOOKUP_OPEN
)) {
342 /* if the file is going to stay open, then we
343 need to set the desired access properly */
345 if (oflags
& FMODE_READ
)
346 desiredAccess
|= GENERIC_READ
; /* is this too little? */
347 if (oflags
& FMODE_WRITE
)
348 desiredAccess
|= GENERIC_WRITE
;
350 if ((oflags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
351 disposition
= FILE_CREATE
;
352 else if ((oflags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
353 disposition
= FILE_OVERWRITE_IF
;
354 else if ((oflags
& O_CREAT
) == O_CREAT
)
355 disposition
= FILE_OPEN_IF
;
357 cFYI(1, "Create flag not set in create function");
360 /* BB add processing to set equivalent of mode - e.g. via CreateX with
363 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
366 goto cifs_create_out
;
370 * if we're not using unix extensions, see if we need to set
371 * ATTR_READONLY on the create call
373 if (!tcon
->unix_ext
&& (mode
& S_IWUGO
) == 0)
374 create_options
|= CREATE_OPTION_READONLY
;
376 if (tcon
->ses
->capabilities
& CAP_NT_SMBS
)
377 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
,
378 desiredAccess
, create_options
,
379 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
380 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
382 rc
= -EIO
; /* no NT SMB support fall into legacy open below */
385 /* old server, retry the open legacy style */
386 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, disposition
,
387 desiredAccess
, create_options
,
388 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
389 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
392 cFYI(1, "cifs_create returned 0x%x", rc
);
393 goto cifs_create_out
;
396 /* If Open reported that we actually created a file
397 then we now have to set the mode if possible */
398 if ((tcon
->unix_ext
) && (oplock
& CIFS_CREATE_ACTION
)) {
399 struct cifs_unix_set_info_args args
= {
401 .ctime
= NO_CHANGE_64
,
402 .atime
= NO_CHANGE_64
,
403 .mtime
= NO_CHANGE_64
,
407 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
408 args
.uid
= (__u64
) current_fsuid();
409 if (inode
->i_mode
& S_ISGID
)
410 args
.gid
= (__u64
) inode
->i_gid
;
412 args
.gid
= (__u64
) current_fsgid();
414 args
.uid
= NO_CHANGE_64
;
415 args
.gid
= NO_CHANGE_64
;
417 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
419 cifs_sb
->mnt_cifs_flags
&
420 CIFS_MOUNT_MAP_SPECIAL_CHR
);
422 /* BB implement mode setting via Windows security
424 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
426 /* Could set r/o dos attribute if mode & 0222 == 0 */
429 cifs_create_get_file_info
:
430 /* server might mask mode so we have to query for it */
432 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
435 rc
= cifs_get_inode_info(&newinode
, full_path
, buf
,
436 inode
->i_sb
, xid
, &fileHandle
);
438 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
439 newinode
->i_mode
= mode
;
440 if ((oplock
& CIFS_CREATE_ACTION
) &&
441 (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
)) {
442 newinode
->i_uid
= current_fsuid();
443 if (inode
->i_mode
& S_ISGID
)
444 newinode
->i_gid
= inode
->i_gid
;
446 newinode
->i_gid
= current_fsgid();
451 cifs_create_set_dentry
:
453 setup_cifs_dentry(tcon
, direntry
, newinode
);
455 cFYI(1, "Create worked, get_inode_info failed rc = %d", rc
);
457 if (newinode
&& nd
&& (nd
->flags
& LOOKUP_OPEN
)) {
458 struct cifsFileInfo
*pfile_info
;
461 filp
= lookup_instantiate_filp(nd
, direntry
, generic_file_open
);
464 CIFSSMBClose(xid
, tcon
, fileHandle
);
465 goto cifs_create_out
;
468 pfile_info
= cifs_new_fileinfo(newinode
, fileHandle
, filp
,
469 nd
->path
.mnt
, oflags
, oplock
);
470 if (pfile_info
== NULL
) {
472 CIFSSMBClose(xid
, tcon
, fileHandle
);
476 CIFSSMBClose(xid
, tcon
, fileHandle
);
486 int cifs_mknod(struct inode
*inode
, struct dentry
*direntry
, int mode
,
491 struct cifs_sb_info
*cifs_sb
;
492 struct cifsTconInfo
*pTcon
;
493 char *full_path
= NULL
;
494 struct inode
*newinode
= NULL
;
497 FILE_ALL_INFO
*buf
= NULL
;
498 unsigned int bytes_written
;
499 struct win_dev
*pdev
;
501 if (!old_valid_dev(device_number
))
506 cifs_sb
= CIFS_SB(inode
->i_sb
);
507 pTcon
= cifs_sb_tcon(cifs_sb
);
509 full_path
= build_path_from_dentry(direntry
);
510 if (full_path
== NULL
) {
515 if (pTcon
->unix_ext
) {
516 struct cifs_unix_set_info_args args
= {
517 .mode
= mode
& ~current_umask(),
518 .ctime
= NO_CHANGE_64
,
519 .atime
= NO_CHANGE_64
,
520 .mtime
= NO_CHANGE_64
,
521 .device
= device_number
,
523 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
524 args
.uid
= (__u64
) current_fsuid();
525 args
.gid
= (__u64
) current_fsgid();
527 args
.uid
= NO_CHANGE_64
;
528 args
.gid
= NO_CHANGE_64
;
530 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, &args
,
532 cifs_sb
->mnt_cifs_flags
&
533 CIFS_MOUNT_MAP_SPECIAL_CHR
);
537 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
540 direntry
->d_op
= &cifs_ci_dentry_ops
;
542 direntry
->d_op
= &cifs_dentry_ops
;
545 d_instantiate(direntry
, newinode
);
549 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 /* FIXME: would WRITE_OWNER | WRITE_DAC be better? */
564 rc
= CIFSSMBOpen(xid
, pTcon
, full_path
, FILE_CREATE
,
565 GENERIC_WRITE
, CREATE_NOT_DIR
| CREATE_OPTION_SPECIAL
,
566 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
567 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
571 /* BB Do not bother to decode buf since no local inode yet to put
572 * timestamps in, but we can reuse it safely */
574 pdev
= (struct win_dev
*)buf
;
576 memcpy(pdev
->type
, "IntxCHR", 8);
578 cpu_to_le64(MAJOR(device_number
));
580 cpu_to_le64(MINOR(device_number
));
581 rc
= CIFSSMBWrite(xid
, pTcon
,
583 sizeof(struct win_dev
),
584 0, &bytes_written
, (char *)pdev
,
586 } else if (S_ISBLK(mode
)) {
587 memcpy(pdev
->type
, "IntxBLK", 8);
589 cpu_to_le64(MAJOR(device_number
));
591 cpu_to_le64(MINOR(device_number
));
592 rc
= CIFSSMBWrite(xid
, pTcon
,
594 sizeof(struct win_dev
),
595 0, &bytes_written
, (char *)pdev
,
597 } /* else if (S_ISFIFO) */
598 CIFSSMBClose(xid
, pTcon
, fileHandle
);
601 /* FIXME: add code here to set EAs */
611 cifs_lookup(struct inode
*parent_dir_inode
, struct dentry
*direntry
,
612 struct nameidata
*nd
)
615 int rc
= 0; /* to get around spurious gcc warning, set to zero here */
617 __u16 fileHandle
= 0;
618 bool posix_open
= false;
619 struct cifs_sb_info
*cifs_sb
;
620 struct cifsTconInfo
*pTcon
;
621 struct cifsFileInfo
*cfile
;
622 struct inode
*newInode
= NULL
;
623 char *full_path
= NULL
;
628 cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
629 parent_dir_inode
, direntry
->d_name
.name
, direntry
);
631 /* check whether path exists */
633 cifs_sb
= CIFS_SB(parent_dir_inode
->i_sb
);
634 pTcon
= cifs_sb_tcon(cifs_sb
);
637 * Don't allow the separator character in a path component.
638 * The VFS will not allow "/", but "\" is allowed by posix.
640 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
)) {
642 for (i
= 0; i
< direntry
->d_name
.len
; i
++)
643 if (direntry
->d_name
.name
[i
] == '\\') {
644 cFYI(1, "Invalid file name");
646 return ERR_PTR(-EINVAL
);
651 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
652 * the VFS handle the create.
654 if (nd
&& (nd
->flags
& LOOKUP_EXCL
)) {
655 d_instantiate(direntry
, NULL
);
659 /* can not grab the rename sem here since it would
660 deadlock in the cases (beginning of sys_rename itself)
661 in which we already have the sb rename sem */
662 full_path
= build_path_from_dentry(direntry
);
663 if (full_path
== NULL
) {
665 return ERR_PTR(-ENOMEM
);
668 if (direntry
->d_inode
!= NULL
) {
669 cFYI(1, "non-NULL inode in lookup");
671 cFYI(1, "NULL inode in lookup");
673 cFYI(1, "Full path: %s inode = 0x%p", full_path
, direntry
->d_inode
);
675 /* Posix open is only called (at lookup time) for file create now.
676 * For opens (rather than creates), because we do not know if it
677 * is a file or directory yet, and current Samba no longer allows
678 * us to do posix open on dirs, we could end up wasting an open call
679 * on what turns out to be a dir. For file opens, we wait to call posix
680 * open till cifs_open. It could be added here (lookup) in the future
681 * but the performance tradeoff of the extra network request when EISDIR
682 * or EACCES is returned would have to be weighed against the 50%
683 * reduction in network traffic in the other paths.
685 if (pTcon
->unix_ext
) {
686 if (nd
&& !(nd
->flags
& (LOOKUP_PARENT
| LOOKUP_DIRECTORY
)) &&
687 (nd
->flags
& LOOKUP_OPEN
) && !pTcon
->broken_posix_open
&&
688 (nd
->intent
.open
.flags
& O_CREAT
)) {
689 rc
= cifs_posix_open(full_path
, &newInode
,
690 parent_dir_inode
->i_sb
,
691 nd
->intent
.open
.create_mode
,
692 nd
->intent
.open
.flags
, &oplock
,
695 * The check below works around a bug in POSIX
696 * open in samba versions 3.3.1 and earlier where
697 * open could incorrectly fail with invalid parameter.
698 * If either that or op not supported returned, follow
701 if ((rc
== 0) || (rc
== -ENOENT
))
703 else if ((rc
== -EINVAL
) || (rc
!= -EOPNOTSUPP
))
704 pTcon
->broken_posix_open
= true;
707 rc
= cifs_get_inode_info_unix(&newInode
, full_path
,
708 parent_dir_inode
->i_sb
, xid
);
710 rc
= cifs_get_inode_info(&newInode
, full_path
, NULL
,
711 parent_dir_inode
->i_sb
, xid
, NULL
);
713 if ((rc
== 0) && (newInode
!= NULL
)) {
715 direntry
->d_op
= &cifs_ci_dentry_ops
;
717 direntry
->d_op
= &cifs_dentry_ops
;
718 d_add(direntry
, newInode
);
720 filp
= lookup_instantiate_filp(nd
, direntry
,
724 CIFSSMBClose(xid
, pTcon
, fileHandle
);
728 cfile
= cifs_new_fileinfo(newInode
, fileHandle
, filp
,
730 nd
->intent
.open
.flags
,
734 CIFSSMBClose(xid
, pTcon
, fileHandle
);
739 /* since paths are not looked up by component - the parent
740 directories are presumed to be good here */
741 renew_parental_timestamps(direntry
);
743 } else if (rc
== -ENOENT
) {
745 direntry
->d_time
= jiffies
;
747 direntry
->d_op
= &cifs_ci_dentry_ops
;
749 direntry
->d_op
= &cifs_dentry_ops
;
750 d_add(direntry
, NULL
);
751 /* if it was once a directory (but how can we tell?) we could do
752 shrink_dcache_parent(direntry); */
753 } else if (rc
!= -EACCES
) {
754 cERROR(1, "Unexpected lookup error %d", rc
);
755 /* We special case check for Access Denied - since that
756 is a common return code */
766 cifs_d_revalidate(struct dentry
*direntry
, struct nameidata
*nd
)
770 if (direntry
->d_inode
) {
771 if (cifs_revalidate_dentry(direntry
))
774 cFYI(1, "neg dentry 0x%p name = %s",
775 direntry
, direntry
->d_name
.name
);
776 if (time_after(jiffies
, direntry
->d_time
+ HZ
) ||
777 !lookupCacheEnabled
) {
786 /* static int cifs_d_delete(struct dentry *direntry)
790 cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
795 const struct dentry_operations cifs_dentry_ops
= {
796 .d_revalidate
= cifs_d_revalidate
,
797 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
800 static int cifs_ci_hash(struct dentry
*dentry
, struct qstr
*q
)
802 struct nls_table
*codepage
= CIFS_SB(dentry
->d_inode
->i_sb
)->local_nls
;
806 hash
= init_name_hash();
807 for (i
= 0; i
< q
->len
; i
++)
808 hash
= partial_name_hash(nls_tolower(codepage
, q
->name
[i
]),
810 q
->hash
= end_name_hash(hash
);
815 static int cifs_ci_compare(struct dentry
*dentry
, struct qstr
*a
,
818 struct nls_table
*codepage
= CIFS_SB(dentry
->d_inode
->i_sb
)->local_nls
;
820 if ((a
->len
== b
->len
) &&
821 (nls_strnicmp(codepage
, a
->name
, b
->name
, a
->len
) == 0)) {
823 * To preserve case, don't let an existing negative dentry's
824 * case take precedence. If a is not a negative dentry, this
825 * should have no side effects
827 memcpy((void *)a
->name
, b
->name
, a
->len
);
833 const struct dentry_operations cifs_ci_dentry_ops
= {
834 .d_revalidate
= cifs_d_revalidate
,
835 .d_hash
= cifs_ci_hash
,
836 .d_compare
= cifs_ci_compare
,