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 /* Inode operations in similar order to how they appear in Linux file fs.h */
136 cifs_create(struct inode
*inode
, struct dentry
*direntry
, int mode
,
137 struct nameidata
*nd
)
141 int create_options
= CREATE_NOT_DIR
;
145 * BB below access is probably too much for mknod to request
146 * but we have to do query and setpathinfo so requesting
147 * less could fail (unless we want to request getatr and setatr
148 * permissions (only). At least for POSIX we do not have to
151 int desiredAccess
= GENERIC_READ
| GENERIC_WRITE
;
153 struct cifs_sb_info
*cifs_sb
;
154 struct tcon_link
*tlink
;
155 struct cifsTconInfo
*tcon
;
156 char *full_path
= NULL
;
157 FILE_ALL_INFO
*buf
= NULL
;
158 struct inode
*newinode
= NULL
;
159 int disposition
= FILE_OVERWRITE_IF
;
163 cifs_sb
= CIFS_SB(inode
->i_sb
);
164 tlink
= cifs_sb_tlink(cifs_sb
);
167 return PTR_ERR(tlink
);
169 tcon
= tlink_tcon(tlink
);
174 if (nd
&& (nd
->flags
& LOOKUP_OPEN
))
175 oflags
= nd
->intent
.open
.file
->f_flags
;
177 oflags
= O_RDONLY
| O_CREAT
;
179 full_path
= build_path_from_dentry(direntry
);
180 if (full_path
== NULL
) {
182 goto cifs_create_out
;
185 if (tcon
->unix_ext
&& (tcon
->ses
->capabilities
& CAP_UNIX
) &&
186 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
187 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
188 rc
= cifs_posix_open(full_path
, &newinode
,
189 inode
->i_sb
, mode
, oflags
, &oplock
, &fileHandle
, xid
);
190 /* EIO could indicate that (posix open) operation is not
191 supported, despite what server claimed in capability
192 negotation. EREMOTE indicates DFS junction, which is not
193 handled in posix open */
196 if (newinode
== NULL
) /* query inode info */
197 goto cifs_create_get_file_info
;
198 else /* success, no need to query */
199 goto cifs_create_set_dentry
;
200 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
201 (rc
!= -EOPNOTSUPP
) && (rc
!= -EINVAL
))
202 goto cifs_create_out
;
203 /* else fallthrough to retry, using older open call, this is
204 case where server does not support this SMB level, and
205 falsely claims capability (also get here for DFS case
206 which should be rare for path not covered on files) */
209 if (nd
&& (nd
->flags
& LOOKUP_OPEN
)) {
210 /* if the file is going to stay open, then we
211 need to set the desired access properly */
213 if (OPEN_FMODE(oflags
) & FMODE_READ
)
214 desiredAccess
|= GENERIC_READ
; /* is this too little? */
215 if (OPEN_FMODE(oflags
) & FMODE_WRITE
)
216 desiredAccess
|= GENERIC_WRITE
;
218 if ((oflags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
219 disposition
= FILE_CREATE
;
220 else if ((oflags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
221 disposition
= FILE_OVERWRITE_IF
;
222 else if ((oflags
& O_CREAT
) == O_CREAT
)
223 disposition
= FILE_OPEN_IF
;
225 cFYI(1, "Create flag not set in create function");
228 /* BB add processing to set equivalent of mode - e.g. via CreateX with
231 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
234 goto cifs_create_out
;
238 * if we're not using unix extensions, see if we need to set
239 * ATTR_READONLY on the create call
241 if (!tcon
->unix_ext
&& (mode
& S_IWUGO
) == 0)
242 create_options
|= CREATE_OPTION_READONLY
;
244 if (tcon
->ses
->capabilities
& CAP_NT_SMBS
)
245 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
,
246 desiredAccess
, create_options
,
247 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
248 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
250 rc
= -EIO
; /* no NT SMB support fall into legacy open below */
253 /* old server, retry the open legacy style */
254 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, disposition
,
255 desiredAccess
, create_options
,
256 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
257 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
260 cFYI(1, "cifs_create returned 0x%x", rc
);
261 goto cifs_create_out
;
264 /* If Open reported that we actually created a file
265 then we now have to set the mode if possible */
266 if ((tcon
->unix_ext
) && (oplock
& CIFS_CREATE_ACTION
)) {
267 struct cifs_unix_set_info_args args
= {
269 .ctime
= NO_CHANGE_64
,
270 .atime
= NO_CHANGE_64
,
271 .mtime
= NO_CHANGE_64
,
275 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
276 args
.uid
= (__u64
) current_fsuid();
277 if (inode
->i_mode
& S_ISGID
)
278 args
.gid
= (__u64
) inode
->i_gid
;
280 args
.gid
= (__u64
) current_fsgid();
282 args
.uid
= NO_CHANGE_64
;
283 args
.gid
= NO_CHANGE_64
;
285 CIFSSMBUnixSetFileInfo(xid
, tcon
, &args
, fileHandle
,
288 /* BB implement mode setting via Windows security
290 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
292 /* Could set r/o dos attribute if mode & 0222 == 0 */
295 cifs_create_get_file_info
:
296 /* server might mask mode so we have to query for it */
298 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
301 rc
= cifs_get_inode_info(&newinode
, full_path
, buf
,
302 inode
->i_sb
, xid
, &fileHandle
);
304 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
305 newinode
->i_mode
= mode
;
306 if ((oplock
& CIFS_CREATE_ACTION
) &&
307 (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
)) {
308 newinode
->i_uid
= current_fsuid();
309 if (inode
->i_mode
& S_ISGID
)
310 newinode
->i_gid
= inode
->i_gid
;
312 newinode
->i_gid
= current_fsgid();
317 cifs_create_set_dentry
:
319 d_instantiate(direntry
, newinode
);
321 cFYI(1, "Create worked, get_inode_info failed rc = %d", rc
);
323 if (newinode
&& nd
&& (nd
->flags
& LOOKUP_OPEN
)) {
324 struct cifsFileInfo
*pfile_info
;
327 filp
= lookup_instantiate_filp(nd
, direntry
, generic_file_open
);
330 CIFSSMBClose(xid
, tcon
, fileHandle
);
331 goto cifs_create_out
;
334 pfile_info
= cifs_new_fileinfo(fileHandle
, filp
, tlink
, oplock
);
335 if (pfile_info
== NULL
) {
337 CIFSSMBClose(xid
, tcon
, fileHandle
);
341 CIFSSMBClose(xid
, tcon
, fileHandle
);
347 cifs_put_tlink(tlink
);
352 int cifs_mknod(struct inode
*inode
, struct dentry
*direntry
, int mode
,
357 struct cifs_sb_info
*cifs_sb
;
358 struct tcon_link
*tlink
;
359 struct cifsTconInfo
*pTcon
;
360 char *full_path
= NULL
;
361 struct inode
*newinode
= NULL
;
364 FILE_ALL_INFO
*buf
= NULL
;
365 unsigned int bytes_written
;
366 struct win_dev
*pdev
;
368 if (!old_valid_dev(device_number
))
371 cifs_sb
= CIFS_SB(inode
->i_sb
);
372 tlink
= cifs_sb_tlink(cifs_sb
);
374 return PTR_ERR(tlink
);
376 pTcon
= tlink_tcon(tlink
);
380 full_path
= build_path_from_dentry(direntry
);
381 if (full_path
== NULL
) {
386 if (pTcon
->unix_ext
) {
387 struct cifs_unix_set_info_args args
= {
388 .mode
= mode
& ~current_umask(),
389 .ctime
= NO_CHANGE_64
,
390 .atime
= NO_CHANGE_64
,
391 .mtime
= NO_CHANGE_64
,
392 .device
= device_number
,
394 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
395 args
.uid
= (__u64
) current_fsuid();
396 args
.gid
= (__u64
) current_fsgid();
398 args
.uid
= NO_CHANGE_64
;
399 args
.gid
= NO_CHANGE_64
;
401 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, &args
,
403 cifs_sb
->mnt_cifs_flags
&
404 CIFS_MOUNT_MAP_SPECIAL_CHR
);
408 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
412 d_instantiate(direntry
, newinode
);
416 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
))
420 cFYI(1, "sfu compat create special file");
422 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
430 /* FIXME: would WRITE_OWNER | WRITE_DAC be better? */
431 rc
= CIFSSMBOpen(xid
, pTcon
, full_path
, FILE_CREATE
,
432 GENERIC_WRITE
, CREATE_NOT_DIR
| CREATE_OPTION_SPECIAL
,
433 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
434 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
438 /* BB Do not bother to decode buf since no local inode yet to put
439 * timestamps in, but we can reuse it safely */
441 pdev
= (struct win_dev
*)buf
;
443 memcpy(pdev
->type
, "IntxCHR", 8);
445 cpu_to_le64(MAJOR(device_number
));
447 cpu_to_le64(MINOR(device_number
));
448 rc
= CIFSSMBWrite(xid
, pTcon
,
450 sizeof(struct win_dev
),
451 0, &bytes_written
, (char *)pdev
,
453 } else if (S_ISBLK(mode
)) {
454 memcpy(pdev
->type
, "IntxBLK", 8);
456 cpu_to_le64(MAJOR(device_number
));
458 cpu_to_le64(MINOR(device_number
));
459 rc
= CIFSSMBWrite(xid
, pTcon
,
461 sizeof(struct win_dev
),
462 0, &bytes_written
, (char *)pdev
,
464 } /* else if (S_ISFIFO) */
465 CIFSSMBClose(xid
, pTcon
, fileHandle
);
468 /* FIXME: add code here to set EAs */
474 cifs_put_tlink(tlink
);
479 cifs_lookup(struct inode
*parent_dir_inode
, struct dentry
*direntry
,
480 struct nameidata
*nd
)
483 int rc
= 0; /* to get around spurious gcc warning, set to zero here */
485 __u16 fileHandle
= 0;
486 bool posix_open
= false;
487 struct cifs_sb_info
*cifs_sb
;
488 struct tcon_link
*tlink
;
489 struct cifsTconInfo
*pTcon
;
490 struct cifsFileInfo
*cfile
;
491 struct inode
*newInode
= NULL
;
492 char *full_path
= NULL
;
497 cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
498 parent_dir_inode
, direntry
->d_name
.name
, direntry
);
500 /* check whether path exists */
502 cifs_sb
= CIFS_SB(parent_dir_inode
->i_sb
);
503 tlink
= cifs_sb_tlink(cifs_sb
);
506 return (struct dentry
*)tlink
;
508 pTcon
= tlink_tcon(tlink
);
511 * Don't allow the separator character in a path component.
512 * The VFS will not allow "/", but "\" is allowed by posix.
514 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
)) {
516 for (i
= 0; i
< direntry
->d_name
.len
; i
++)
517 if (direntry
->d_name
.name
[i
] == '\\') {
518 cFYI(1, "Invalid file name");
525 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
526 * the VFS handle the create.
528 if (nd
&& (nd
->flags
& LOOKUP_EXCL
)) {
529 d_instantiate(direntry
, NULL
);
534 /* can not grab the rename sem here since it would
535 deadlock in the cases (beginning of sys_rename itself)
536 in which we already have the sb rename sem */
537 full_path
= build_path_from_dentry(direntry
);
538 if (full_path
== NULL
) {
543 if (direntry
->d_inode
!= NULL
) {
544 cFYI(1, "non-NULL inode in lookup");
546 cFYI(1, "NULL inode in lookup");
548 cFYI(1, "Full path: %s inode = 0x%p", full_path
, direntry
->d_inode
);
550 /* Posix open is only called (at lookup time) for file create now.
551 * For opens (rather than creates), because we do not know if it
552 * is a file or directory yet, and current Samba no longer allows
553 * us to do posix open on dirs, we could end up wasting an open call
554 * on what turns out to be a dir. For file opens, we wait to call posix
555 * open till cifs_open. It could be added here (lookup) in the future
556 * but the performance tradeoff of the extra network request when EISDIR
557 * or EACCES is returned would have to be weighed against the 50%
558 * reduction in network traffic in the other paths.
560 if (pTcon
->unix_ext
) {
561 if (nd
&& !(nd
->flags
& (LOOKUP_PARENT
| LOOKUP_DIRECTORY
)) &&
562 (nd
->flags
& LOOKUP_OPEN
) && !pTcon
->broken_posix_open
&&
563 (nd
->intent
.open
.file
->f_flags
& O_CREAT
)) {
564 rc
= cifs_posix_open(full_path
, &newInode
,
565 parent_dir_inode
->i_sb
,
566 nd
->intent
.open
.create_mode
,
567 nd
->intent
.open
.file
->f_flags
, &oplock
,
570 * The check below works around a bug in POSIX
571 * open in samba versions 3.3.1 and earlier where
572 * open could incorrectly fail with invalid parameter.
573 * If either that or op not supported returned, follow
576 if ((rc
== 0) || (rc
== -ENOENT
))
578 else if ((rc
== -EINVAL
) || (rc
!= -EOPNOTSUPP
))
579 pTcon
->broken_posix_open
= true;
582 rc
= cifs_get_inode_info_unix(&newInode
, full_path
,
583 parent_dir_inode
->i_sb
, xid
);
585 rc
= cifs_get_inode_info(&newInode
, full_path
, NULL
,
586 parent_dir_inode
->i_sb
, xid
, NULL
);
588 if ((rc
== 0) && (newInode
!= NULL
)) {
589 d_add(direntry
, newInode
);
591 filp
= lookup_instantiate_filp(nd
, direntry
,
595 CIFSSMBClose(xid
, pTcon
, fileHandle
);
599 cfile
= cifs_new_fileinfo(fileHandle
, filp
, tlink
,
603 CIFSSMBClose(xid
, pTcon
, fileHandle
);
608 /* since paths are not looked up by component - the parent
609 directories are presumed to be good here */
610 renew_parental_timestamps(direntry
);
612 } else if (rc
== -ENOENT
) {
614 direntry
->d_time
= jiffies
;
615 d_add(direntry
, NULL
);
616 /* if it was once a directory (but how can we tell?) we could do
617 shrink_dcache_parent(direntry); */
618 } else if (rc
!= -EACCES
) {
619 cERROR(1, "Unexpected lookup error %d", rc
);
620 /* We special case check for Access Denied - since that
621 is a common return code */
626 cifs_put_tlink(tlink
);
632 cifs_d_revalidate(struct dentry
*direntry
, struct nameidata
*nd
)
634 if (nd
->flags
& LOOKUP_RCU
)
637 if (direntry
->d_inode
) {
638 if (cifs_revalidate_dentry(direntry
))
645 * This may be nfsd (or something), anyway, we can't see the
646 * intent of this. So, since this can be for creation, drop it.
652 * Drop the negative dentry, in order to make sure to use the
653 * case sensitive name which is specified by user if this is
656 if (!(nd
->flags
& (LOOKUP_CONTINUE
| LOOKUP_PARENT
))) {
657 if (nd
->flags
& (LOOKUP_CREATE
| LOOKUP_RENAME_TARGET
))
661 if (time_after(jiffies
, direntry
->d_time
+ HZ
) || !lookupCacheEnabled
)
667 /* static int cifs_d_delete(struct dentry *direntry)
671 cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
676 const struct dentry_operations cifs_dentry_ops
= {
677 .d_revalidate
= cifs_d_revalidate
,
678 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
681 static int cifs_ci_hash(const struct dentry
*dentry
, const struct inode
*inode
,
684 struct nls_table
*codepage
= CIFS_SB(dentry
->d_sb
)->local_nls
;
688 hash
= init_name_hash();
689 for (i
= 0; i
< q
->len
; i
++)
690 hash
= partial_name_hash(nls_tolower(codepage
, q
->name
[i
]),
692 q
->hash
= end_name_hash(hash
);
697 static int cifs_ci_compare(const struct dentry
*parent
,
698 const struct inode
*pinode
,
699 const struct dentry
*dentry
, const struct inode
*inode
,
700 unsigned int len
, const char *str
, const struct qstr
*name
)
702 struct nls_table
*codepage
= CIFS_SB(pinode
->i_sb
)->local_nls
;
704 if ((name
->len
== len
) &&
705 (nls_strnicmp(codepage
, name
->name
, str
, len
) == 0))
710 const struct dentry_operations cifs_ci_dentry_ops
= {
711 .d_revalidate
= cifs_d_revalidate
,
712 .d_hash
= cifs_ci_hash
,
713 .d_compare
= cifs_ci_compare
,