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
= CIFS_SB(direntry
->d_sb
);
58 struct cifsTconInfo
*tcon
= cifs_sb_master_tcon(cifs_sb
);
61 return NULL
; /* not much we can do if dentry is freed and
62 we need to reopen the file after it was closed implicitly
63 when the server crashed */
65 dirsep
= CIFS_DIR_SEP(cifs_sb
);
66 pplen
= cifs_sb
->prepathlen
;
67 if (tcon
->Flags
& SMB_SHARE_IS_IN_DFS
)
68 dfsplen
= strnlen(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
, 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
, struct file
*file
,
135 struct vfsmount
*mnt
, struct cifsTconInfo
*tcon
,
136 unsigned int oflags
, __u32 oplock
)
138 struct cifsFileInfo
*pCifsFile
;
139 struct cifsInodeInfo
*pCifsInode
;
141 pCifsFile
= kzalloc(sizeof(struct cifsFileInfo
), GFP_KERNEL
);
142 if (pCifsFile
== NULL
)
145 pCifsFile
->netfid
= fileHandle
;
146 pCifsFile
->pid
= current
->tgid
;
147 pCifsFile
->pInode
= igrab(newinode
);
148 pCifsFile
->mnt
= mnt
;
149 pCifsFile
->pfile
= file
;
150 pCifsFile
->invalidHandle
= false;
151 pCifsFile
->closePend
= false;
152 pCifsFile
->tcon
= tcon
;
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
, &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
;
193 struct tcon_link
*tlink
;
194 struct cifsTconInfo
*tcon
;
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
;
218 /* be safe and imply O_SYNC for O_DSYNC */
219 if (oflags
& O_DSYNC
)
220 posix_flags
|= SMB_O_SYNC
;
221 if (oflags
& O_DIRECTORY
)
222 posix_flags
|= SMB_O_DIRECTORY
;
223 if (oflags
& O_NOFOLLOW
)
224 posix_flags
|= SMB_O_NOFOLLOW
;
225 if (oflags
& O_DIRECT
)
226 posix_flags
|= SMB_O_DIRECT
;
228 mode
&= ~current_umask();
230 tlink
= cifs_sb_tlink(cifs_sb
);
236 tcon
= tlink_tcon(tlink
);
237 rc
= CIFSPOSIXCreate(xid
, tcon
, posix_flags
, mode
, pnetfid
, presp_data
,
238 poplock
, full_path
, cifs_sb
->local_nls
,
239 cifs_sb
->mnt_cifs_flags
&
240 CIFS_MOUNT_MAP_SPECIAL_CHR
);
241 cifs_put_tlink(tlink
);
246 if (presp_data
->Type
== cpu_to_le32(-1))
247 goto posix_open_ret
; /* open ok, caller does qpathinfo */
250 goto posix_open_ret
; /* caller does not need info */
252 cifs_unix_basic_to_fattr(&fattr
, presp_data
, cifs_sb
);
254 /* get new inode and set it up */
255 if (*pinode
== NULL
) {
256 cifs_fill_uniqueid(sb
, &fattr
);
257 *pinode
= cifs_iget(sb
, &fattr
);
263 cifs_fattr_to_inode(*pinode
, &fattr
);
271 static void setup_cifs_dentry(struct cifsTconInfo
*tcon
,
272 struct dentry
*direntry
,
273 struct inode
*newinode
)
276 direntry
->d_op
= &cifs_ci_dentry_ops
;
278 direntry
->d_op
= &cifs_dentry_ops
;
279 d_instantiate(direntry
, newinode
);
282 /* Inode operations in similar order to how they appear in Linux file fs.h */
285 cifs_create(struct inode
*inode
, struct dentry
*direntry
, int mode
,
286 struct nameidata
*nd
)
290 int create_options
= CREATE_NOT_DIR
;
294 * BB below access is probably too much for mknod to request
295 * but we have to do query and setpathinfo so requesting
296 * less could fail (unless we want to request getatr and setatr
297 * permissions (only). At least for POSIX we do not have to
300 int desiredAccess
= GENERIC_READ
| GENERIC_WRITE
;
302 struct cifs_sb_info
*cifs_sb
;
303 struct tcon_link
*tlink
;
304 struct cifsTconInfo
*tcon
;
305 char *full_path
= NULL
;
306 FILE_ALL_INFO
*buf
= NULL
;
307 struct inode
*newinode
= NULL
;
308 int disposition
= FILE_OVERWRITE_IF
;
312 cifs_sb
= CIFS_SB(inode
->i_sb
);
313 tlink
= cifs_sb_tlink(cifs_sb
);
316 return PTR_ERR(tlink
);
318 tcon
= tlink_tcon(tlink
);
323 if (nd
&& (nd
->flags
& LOOKUP_OPEN
))
324 oflags
= nd
->intent
.open
.flags
;
326 oflags
= FMODE_READ
| SMB_O_CREAT
;
328 full_path
= build_path_from_dentry(direntry
);
329 if (full_path
== NULL
) {
331 goto cifs_create_out
;
334 if (tcon
->unix_ext
&& (tcon
->ses
->capabilities
& CAP_UNIX
) &&
335 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
336 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
337 rc
= cifs_posix_open(full_path
, &newinode
,
338 inode
->i_sb
, mode
, oflags
, &oplock
, &fileHandle
, xid
);
339 /* EIO could indicate that (posix open) operation is not
340 supported, despite what server claimed in capability
341 negotation. EREMOTE indicates DFS junction, which is not
342 handled in posix open */
345 if (newinode
== NULL
) /* query inode info */
346 goto cifs_create_get_file_info
;
347 else /* success, no need to query */
348 goto cifs_create_set_dentry
;
349 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
350 (rc
!= -EOPNOTSUPP
) && (rc
!= -EINVAL
))
351 goto cifs_create_out
;
352 /* else fallthrough to retry, using older open call, this is
353 case where server does not support this SMB level, and
354 falsely claims capability (also get here for DFS case
355 which should be rare for path not covered on files) */
358 if (nd
&& (nd
->flags
& LOOKUP_OPEN
)) {
359 /* if the file is going to stay open, then we
360 need to set the desired access properly */
362 if (oflags
& FMODE_READ
)
363 desiredAccess
|= GENERIC_READ
; /* is this too little? */
364 if (oflags
& FMODE_WRITE
)
365 desiredAccess
|= GENERIC_WRITE
;
367 if ((oflags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
368 disposition
= FILE_CREATE
;
369 else if ((oflags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
370 disposition
= FILE_OVERWRITE_IF
;
371 else if ((oflags
& O_CREAT
) == O_CREAT
)
372 disposition
= FILE_OPEN_IF
;
374 cFYI(1, "Create flag not set in create function");
377 /* BB add processing to set equivalent of mode - e.g. via CreateX with
380 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
383 goto cifs_create_out
;
387 * if we're not using unix extensions, see if we need to set
388 * ATTR_READONLY on the create call
390 if (!tcon
->unix_ext
&& (mode
& S_IWUGO
) == 0)
391 create_options
|= CREATE_OPTION_READONLY
;
393 if (tcon
->ses
->capabilities
& CAP_NT_SMBS
)
394 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
,
395 desiredAccess
, create_options
,
396 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
397 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
399 rc
= -EIO
; /* no NT SMB support fall into legacy open below */
402 /* old server, retry the open legacy style */
403 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, disposition
,
404 desiredAccess
, create_options
,
405 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
406 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
409 cFYI(1, "cifs_create returned 0x%x", rc
);
410 goto cifs_create_out
;
413 /* If Open reported that we actually created a file
414 then we now have to set the mode if possible */
415 if ((tcon
->unix_ext
) && (oplock
& CIFS_CREATE_ACTION
)) {
416 struct cifs_unix_set_info_args args
= {
418 .ctime
= NO_CHANGE_64
,
419 .atime
= NO_CHANGE_64
,
420 .mtime
= NO_CHANGE_64
,
424 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
425 args
.uid
= (__u64
) current_fsuid();
426 if (inode
->i_mode
& S_ISGID
)
427 args
.gid
= (__u64
) inode
->i_gid
;
429 args
.gid
= (__u64
) current_fsgid();
431 args
.uid
= NO_CHANGE_64
;
432 args
.gid
= NO_CHANGE_64
;
434 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
436 cifs_sb
->mnt_cifs_flags
&
437 CIFS_MOUNT_MAP_SPECIAL_CHR
);
439 /* BB implement mode setting via Windows security
441 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
443 /* Could set r/o dos attribute if mode & 0222 == 0 */
446 cifs_create_get_file_info
:
447 /* server might mask mode so we have to query for it */
449 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
452 rc
= cifs_get_inode_info(&newinode
, full_path
, buf
,
453 inode
->i_sb
, xid
, &fileHandle
);
455 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
456 newinode
->i_mode
= mode
;
457 if ((oplock
& CIFS_CREATE_ACTION
) &&
458 (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
)) {
459 newinode
->i_uid
= current_fsuid();
460 if (inode
->i_mode
& S_ISGID
)
461 newinode
->i_gid
= inode
->i_gid
;
463 newinode
->i_gid
= current_fsgid();
468 cifs_create_set_dentry
:
470 setup_cifs_dentry(tcon
, direntry
, newinode
);
472 cFYI(1, "Create worked, get_inode_info failed rc = %d", rc
);
474 if (newinode
&& nd
&& (nd
->flags
& LOOKUP_OPEN
)) {
475 struct cifsFileInfo
*pfile_info
;
478 filp
= lookup_instantiate_filp(nd
, direntry
, generic_file_open
);
481 CIFSSMBClose(xid
, tcon
, fileHandle
);
482 goto cifs_create_out
;
485 pfile_info
= cifs_new_fileinfo(newinode
, fileHandle
, filp
,
486 nd
->path
.mnt
, tcon
, oflags
,
488 if (pfile_info
== NULL
) {
490 CIFSSMBClose(xid
, tcon
, fileHandle
);
494 CIFSSMBClose(xid
, tcon
, fileHandle
);
500 cifs_put_tlink(tlink
);
505 int cifs_mknod(struct inode
*inode
, struct dentry
*direntry
, int mode
,
510 struct cifs_sb_info
*cifs_sb
;
511 struct tcon_link
*tlink
;
512 struct cifsTconInfo
*pTcon
;
513 char *full_path
= NULL
;
514 struct inode
*newinode
= NULL
;
517 FILE_ALL_INFO
*buf
= NULL
;
518 unsigned int bytes_written
;
519 struct win_dev
*pdev
;
521 if (!old_valid_dev(device_number
))
524 cifs_sb
= CIFS_SB(inode
->i_sb
);
525 tlink
= cifs_sb_tlink(cifs_sb
);
527 return PTR_ERR(tlink
);
529 pTcon
= tlink_tcon(tlink
);
533 full_path
= build_path_from_dentry(direntry
);
534 if (full_path
== NULL
) {
539 if (pTcon
->unix_ext
) {
540 struct cifs_unix_set_info_args args
= {
541 .mode
= mode
& ~current_umask(),
542 .ctime
= NO_CHANGE_64
,
543 .atime
= NO_CHANGE_64
,
544 .mtime
= NO_CHANGE_64
,
545 .device
= device_number
,
547 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
548 args
.uid
= (__u64
) current_fsuid();
549 args
.gid
= (__u64
) current_fsgid();
551 args
.uid
= NO_CHANGE_64
;
552 args
.gid
= NO_CHANGE_64
;
554 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, &args
,
556 cifs_sb
->mnt_cifs_flags
&
557 CIFS_MOUNT_MAP_SPECIAL_CHR
);
561 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
564 direntry
->d_op
= &cifs_ci_dentry_ops
;
566 direntry
->d_op
= &cifs_dentry_ops
;
569 d_instantiate(direntry
, newinode
);
573 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
))
577 cFYI(1, "sfu compat create special file");
579 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
587 /* FIXME: would WRITE_OWNER | WRITE_DAC be better? */
588 rc
= CIFSSMBOpen(xid
, pTcon
, full_path
, FILE_CREATE
,
589 GENERIC_WRITE
, CREATE_NOT_DIR
| CREATE_OPTION_SPECIAL
,
590 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
591 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
595 /* BB Do not bother to decode buf since no local inode yet to put
596 * timestamps in, but we can reuse it safely */
598 pdev
= (struct win_dev
*)buf
;
600 memcpy(pdev
->type
, "IntxCHR", 8);
602 cpu_to_le64(MAJOR(device_number
));
604 cpu_to_le64(MINOR(device_number
));
605 rc
= CIFSSMBWrite(xid
, pTcon
,
607 sizeof(struct win_dev
),
608 0, &bytes_written
, (char *)pdev
,
610 } else if (S_ISBLK(mode
)) {
611 memcpy(pdev
->type
, "IntxBLK", 8);
613 cpu_to_le64(MAJOR(device_number
));
615 cpu_to_le64(MINOR(device_number
));
616 rc
= CIFSSMBWrite(xid
, pTcon
,
618 sizeof(struct win_dev
),
619 0, &bytes_written
, (char *)pdev
,
621 } /* else if (S_ISFIFO) */
622 CIFSSMBClose(xid
, pTcon
, fileHandle
);
625 /* FIXME: add code here to set EAs */
631 cifs_put_tlink(tlink
);
636 cifs_lookup(struct inode
*parent_dir_inode
, struct dentry
*direntry
,
637 struct nameidata
*nd
)
640 int rc
= 0; /* to get around spurious gcc warning, set to zero here */
642 __u16 fileHandle
= 0;
643 bool posix_open
= false;
644 struct cifs_sb_info
*cifs_sb
;
645 struct tcon_link
*tlink
;
646 struct cifsTconInfo
*pTcon
;
647 struct cifsFileInfo
*cfile
;
648 struct inode
*newInode
= NULL
;
649 char *full_path
= NULL
;
654 cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
655 parent_dir_inode
, direntry
->d_name
.name
, direntry
);
657 /* check whether path exists */
659 cifs_sb
= CIFS_SB(parent_dir_inode
->i_sb
);
660 tlink
= cifs_sb_tlink(cifs_sb
);
663 return (struct dentry
*)tlink
;
665 pTcon
= tlink_tcon(tlink
);
668 * Don't allow the separator character in a path component.
669 * The VFS will not allow "/", but "\" is allowed by posix.
671 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
)) {
673 for (i
= 0; i
< direntry
->d_name
.len
; i
++)
674 if (direntry
->d_name
.name
[i
] == '\\') {
675 cFYI(1, "Invalid file name");
682 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
683 * the VFS handle the create.
685 if (nd
&& (nd
->flags
& LOOKUP_EXCL
)) {
686 d_instantiate(direntry
, NULL
);
691 /* can not grab the rename sem here since it would
692 deadlock in the cases (beginning of sys_rename itself)
693 in which we already have the sb rename sem */
694 full_path
= build_path_from_dentry(direntry
);
695 if (full_path
== NULL
) {
700 if (direntry
->d_inode
!= NULL
) {
701 cFYI(1, "non-NULL inode in lookup");
703 cFYI(1, "NULL inode in lookup");
705 cFYI(1, "Full path: %s inode = 0x%p", full_path
, direntry
->d_inode
);
707 /* Posix open is only called (at lookup time) for file create now.
708 * For opens (rather than creates), because we do not know if it
709 * is a file or directory yet, and current Samba no longer allows
710 * us to do posix open on dirs, we could end up wasting an open call
711 * on what turns out to be a dir. For file opens, we wait to call posix
712 * open till cifs_open. It could be added here (lookup) in the future
713 * but the performance tradeoff of the extra network request when EISDIR
714 * or EACCES is returned would have to be weighed against the 50%
715 * reduction in network traffic in the other paths.
717 if (pTcon
->unix_ext
) {
718 if (nd
&& !(nd
->flags
& (LOOKUP_PARENT
| LOOKUP_DIRECTORY
)) &&
719 (nd
->flags
& LOOKUP_OPEN
) && !pTcon
->broken_posix_open
&&
720 (nd
->intent
.open
.flags
& O_CREAT
)) {
721 rc
= cifs_posix_open(full_path
, &newInode
,
722 parent_dir_inode
->i_sb
,
723 nd
->intent
.open
.create_mode
,
724 nd
->intent
.open
.flags
, &oplock
,
727 * The check below works around a bug in POSIX
728 * open in samba versions 3.3.1 and earlier where
729 * open could incorrectly fail with invalid parameter.
730 * If either that or op not supported returned, follow
733 if ((rc
== 0) || (rc
== -ENOENT
))
735 else if ((rc
== -EINVAL
) || (rc
!= -EOPNOTSUPP
))
736 pTcon
->broken_posix_open
= true;
739 rc
= cifs_get_inode_info_unix(&newInode
, full_path
,
740 parent_dir_inode
->i_sb
, xid
);
742 rc
= cifs_get_inode_info(&newInode
, full_path
, NULL
,
743 parent_dir_inode
->i_sb
, xid
, NULL
);
745 if ((rc
== 0) && (newInode
!= NULL
)) {
747 direntry
->d_op
= &cifs_ci_dentry_ops
;
749 direntry
->d_op
= &cifs_dentry_ops
;
750 d_add(direntry
, newInode
);
752 filp
= lookup_instantiate_filp(nd
, direntry
,
756 CIFSSMBClose(xid
, pTcon
, fileHandle
);
760 cfile
= cifs_new_fileinfo(newInode
, fileHandle
, filp
,
762 nd
->intent
.open
.flags
,
766 CIFSSMBClose(xid
, pTcon
, fileHandle
);
771 /* since paths are not looked up by component - the parent
772 directories are presumed to be good here */
773 renew_parental_timestamps(direntry
);
775 } else if (rc
== -ENOENT
) {
777 direntry
->d_time
= jiffies
;
779 direntry
->d_op
= &cifs_ci_dentry_ops
;
781 direntry
->d_op
= &cifs_dentry_ops
;
782 d_add(direntry
, NULL
);
783 /* if it was once a directory (but how can we tell?) we could do
784 shrink_dcache_parent(direntry); */
785 } else if (rc
!= -EACCES
) {
786 cERROR(1, "Unexpected lookup error %d", rc
);
787 /* We special case check for Access Denied - since that
788 is a common return code */
793 cifs_put_tlink(tlink
);
799 cifs_d_revalidate(struct dentry
*direntry
, struct nameidata
*nd
)
803 if (direntry
->d_inode
) {
804 if (cifs_revalidate_dentry(direntry
))
807 cFYI(1, "neg dentry 0x%p name = %s",
808 direntry
, direntry
->d_name
.name
);
809 if (time_after(jiffies
, direntry
->d_time
+ HZ
) ||
810 !lookupCacheEnabled
) {
819 /* static int cifs_d_delete(struct dentry *direntry)
823 cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
828 const struct dentry_operations cifs_dentry_ops
= {
829 .d_revalidate
= cifs_d_revalidate
,
830 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
833 static int cifs_ci_hash(struct dentry
*dentry
, struct qstr
*q
)
835 struct nls_table
*codepage
= CIFS_SB(dentry
->d_inode
->i_sb
)->local_nls
;
839 hash
= init_name_hash();
840 for (i
= 0; i
< q
->len
; i
++)
841 hash
= partial_name_hash(nls_tolower(codepage
, q
->name
[i
]),
843 q
->hash
= end_name_hash(hash
);
848 static int cifs_ci_compare(struct dentry
*dentry
, struct qstr
*a
,
851 struct nls_table
*codepage
= CIFS_SB(dentry
->d_inode
->i_sb
)->local_nls
;
853 if ((a
->len
== b
->len
) &&
854 (nls_strnicmp(codepage
, a
->name
, b
->name
, a
->len
) == 0)) {
856 * To preserve case, don't let an existing negative dentry's
857 * case take precedence. If a is not a negative dentry, this
858 * should have no side effects
860 memcpy((void *)a
->name
, b
->name
, a
->len
);
866 const struct dentry_operations cifs_ci_dentry_ops
= {
867 .d_revalidate
= cifs_d_revalidate
,
868 .d_hash
= cifs_ci_hash
,
869 .d_compare
= cifs_ci_compare
,