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)
56 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
57 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
60 dirsep = CIFS_DIR_SEP(cifs_sb);
61 if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
62 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
67 seq = read_seqbegin(&rename_lock);
69 for (temp = direntry; !IS_ROOT(temp);) {
70 namelen += (1 + temp->d_name.len);
71 temp = temp->d_parent;
73 cERROR(1, "corrupt dentry");
80 full_path = kmalloc(namelen+1, GFP_KERNEL);
81 if (full_path == NULL)
83 full_path[namelen] = 0; /* trailing null */
85 for (temp = direntry; !IS_ROOT(temp);) {
86 spin_lock(&temp->d_lock);
87 namelen -= 1 + temp->d_name.len;
89 spin_unlock(&temp->d_lock);
92 full_path[namelen] = dirsep;
93 strncpy(full_path + namelen + 1, temp->d_name.name,
95 cFYI(0, "name: %s", full_path + namelen);
97 spin_unlock(&temp->d_lock);
98 temp = temp->d_parent;
100 cERROR(1, "corrupt dentry");
107 if (namelen != dfsplen || read_seqretry(&rename_lock, seq)) {
108 cFYI(1, "did not end path lookup where expected. namelen=%d "
109 "dfsplen=%d", namelen, dfsplen);
110 /* presumably this is only possible if racing with a rename
111 of one of the parent directories (we can not lock the dentries
112 above us to prevent this, but retrying should be harmless) */
114 goto cifs_bp_rename_retry;
116 /* DIR_SEP already set for byte 0 / vs \ but not for
117 subsequent slashes in prepath which currently must
118 be entered the right way - not sure if there is an alternative
119 since the '\' is a valid posix character so we can not switch
120 those safely to '/' if any are found in the middle of the prepath */
121 /* BB test paths to Windows with '/' in the midst of prepath */
124 strncpy(full_path, tcon->treeName, dfsplen);
125 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
127 for (i = 0; i < dfsplen; i++) {
128 if (full_path[i] == '\\')
136 /* Inode operations in similar order to how they appear in Linux file fs.h */
139 cifs_create(struct inode *inode, struct dentry *direntry, int mode,
140 struct nameidata *nd)
144 int create_options = CREATE_NOT_DIR;
148 * BB below access is probably too much for mknod to request
149 * but we have to do query and setpathinfo so requesting
150 * less could fail (unless we want to request getatr and setatr
151 * permissions (only). At least for POSIX we do not have to
154 int desiredAccess = GENERIC_READ | GENERIC_WRITE;
156 struct cifs_sb_info *cifs_sb;
157 struct tcon_link *tlink;
158 struct cifs_tcon *tcon;
159 char *full_path = NULL;
160 FILE_ALL_INFO *buf = NULL;
161 struct inode *newinode = NULL;
162 int disposition = FILE_OVERWRITE_IF;
166 cifs_sb = CIFS_SB(inode->i_sb);
167 tlink = cifs_sb_tlink(cifs_sb);
170 return PTR_ERR(tlink);
172 tcon = tlink_tcon(tlink);
178 oflags = nd->intent.open.file->f_flags;
180 oflags = O_RDONLY | O_CREAT;
182 full_path = build_path_from_dentry(direntry);
183 if (full_path == NULL) {
185 goto cifs_create_out;
188 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
189 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
190 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
191 rc = cifs_posix_open(full_path, &newinode,
192 inode->i_sb, mode, oflags, &oplock, &fileHandle, xid);
193 /* EIO could indicate that (posix open) operation is not
194 supported, despite what server claimed in capability
195 negotiation. EREMOTE indicates DFS junction, which is not
196 handled in posix open */
199 if (newinode == NULL) /* query inode info */
200 goto cifs_create_get_file_info;
201 else /* success, no need to query */
202 goto cifs_create_set_dentry;
203 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
204 (rc != -EOPNOTSUPP) && (rc != -EINVAL))
205 goto cifs_create_out;
206 /* else fallthrough to retry, using older open call, this is
207 case where server does not support this SMB level, and
208 falsely claims capability (also get here for DFS case
209 which should be rare for path not covered on files) */
213 /* if the file is going to stay open, then we
214 need to set the desired access properly */
216 if (OPEN_FMODE(oflags) & FMODE_READ)
217 desiredAccess |= GENERIC_READ; /* is this too little? */
218 if (OPEN_FMODE(oflags) & FMODE_WRITE)
219 desiredAccess |= GENERIC_WRITE;
221 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
222 disposition = FILE_CREATE;
223 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
224 disposition = FILE_OVERWRITE_IF;
225 else if ((oflags & O_CREAT) == O_CREAT)
226 disposition = FILE_OPEN_IF;
228 cFYI(1, "Create flag not set in create function");
231 /* BB add processing to set equivalent of mode - e.g. via CreateX with
234 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
237 goto cifs_create_out;
241 * if we're not using unix extensions, see if we need to set
242 * ATTR_READONLY on the create call
244 if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
245 create_options |= CREATE_OPTION_READONLY;
247 if (backup_cred(cifs_sb))
248 create_options |= CREATE_OPEN_BACKUP_INTENT;
250 if (tcon->ses->capabilities & CAP_NT_SMBS)
251 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
252 desiredAccess, create_options,
253 &fileHandle, &oplock, buf, cifs_sb->local_nls,
254 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
256 rc = -EIO; /* no NT SMB support fall into legacy open below */
259 /* old server, retry the open legacy style */
260 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
261 desiredAccess, create_options,
262 &fileHandle, &oplock, buf, cifs_sb->local_nls,
263 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
266 cFYI(1, "cifs_create returned 0x%x", rc);
267 goto cifs_create_out;
270 /* If Open reported that we actually created a file
271 then we now have to set the mode if possible */
272 if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
273 struct cifs_unix_set_info_args args = {
275 .ctime = NO_CHANGE_64,
276 .atime = NO_CHANGE_64,
277 .mtime = NO_CHANGE_64,
281 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
282 args.uid = (__u64) current_fsuid();
283 if (inode->i_mode & S_ISGID)
284 args.gid = (__u64) inode->i_gid;
286 args.gid = (__u64) current_fsgid();
288 args.uid = NO_CHANGE_64;
289 args.gid = NO_CHANGE_64;
291 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fileHandle,
294 /* BB implement mode setting via Windows security
296 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
298 /* Could set r/o dos attribute if mode & 0222 == 0 */
301 cifs_create_get_file_info:
302 /* server might mask mode so we have to query for it */
304 rc = cifs_get_inode_info_unix(&newinode, full_path,
307 rc = cifs_get_inode_info(&newinode, full_path, buf,
308 inode->i_sb, xid, &fileHandle);
310 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
311 newinode->i_mode = mode;
312 if ((oplock & CIFS_CREATE_ACTION) &&
313 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
314 newinode->i_uid = current_fsuid();
315 if (inode->i_mode & S_ISGID)
316 newinode->i_gid = inode->i_gid;
318 newinode->i_gid = current_fsgid();
323 cifs_create_set_dentry:
325 d_instantiate(direntry, newinode);
327 cFYI(1, "Create worked, get_inode_info failed rc = %d", rc);
329 if (newinode && nd) {
330 struct cifsFileInfo *pfile_info;
333 filp = lookup_instantiate_filp(nd, direntry, generic_file_open);
336 CIFSSMBClose(xid, tcon, fileHandle);
337 goto cifs_create_out;
340 pfile_info = cifs_new_fileinfo(fileHandle, filp, tlink, oplock);
341 if (pfile_info == NULL) {
343 CIFSSMBClose(xid, tcon, fileHandle);
347 CIFSSMBClose(xid, tcon, fileHandle);
353 cifs_put_tlink(tlink);
358 int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
363 int create_options = CREATE_NOT_DIR | CREATE_OPTION_SPECIAL;
364 struct cifs_sb_info *cifs_sb;
365 struct tcon_link *tlink;
366 struct cifs_tcon *pTcon;
367 struct cifs_io_parms io_parms;
368 char *full_path = NULL;
369 struct inode *newinode = NULL;
372 FILE_ALL_INFO *buf = NULL;
373 unsigned int bytes_written;
374 struct win_dev *pdev;
376 if (!old_valid_dev(device_number))
379 cifs_sb = CIFS_SB(inode->i_sb);
380 tlink = cifs_sb_tlink(cifs_sb);
382 return PTR_ERR(tlink);
384 pTcon = tlink_tcon(tlink);
388 full_path = build_path_from_dentry(direntry);
389 if (full_path == NULL) {
394 if (pTcon->unix_ext) {
395 struct cifs_unix_set_info_args args = {
396 .mode = mode & ~current_umask(),
397 .ctime = NO_CHANGE_64,
398 .atime = NO_CHANGE_64,
399 .mtime = NO_CHANGE_64,
400 .device = device_number,
402 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
403 args.uid = (__u64) current_fsuid();
404 args.gid = (__u64) current_fsgid();
406 args.uid = NO_CHANGE_64;
407 args.gid = NO_CHANGE_64;
409 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
411 cifs_sb->mnt_cifs_flags &
412 CIFS_MOUNT_MAP_SPECIAL_CHR);
416 rc = cifs_get_inode_info_unix(&newinode, full_path,
420 d_instantiate(direntry, newinode);
424 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
428 cFYI(1, "sfu compat create special file");
430 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
438 if (backup_cred(cifs_sb))
439 create_options |= CREATE_OPEN_BACKUP_INTENT;
441 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_CREATE,
442 GENERIC_WRITE, create_options,
443 &fileHandle, &oplock, buf, cifs_sb->local_nls,
444 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
448 /* BB Do not bother to decode buf since no local inode yet to put
449 * timestamps in, but we can reuse it safely */
451 pdev = (struct win_dev *)buf;
452 io_parms.netfid = fileHandle;
453 io_parms.pid = current->tgid;
454 io_parms.tcon = pTcon;
456 io_parms.length = sizeof(struct win_dev);
458 memcpy(pdev->type, "IntxCHR", 8);
460 cpu_to_le64(MAJOR(device_number));
462 cpu_to_le64(MINOR(device_number));
463 rc = CIFSSMBWrite(xid, &io_parms,
464 &bytes_written, (char *)pdev,
466 } else if (S_ISBLK(mode)) {
467 memcpy(pdev->type, "IntxBLK", 8);
469 cpu_to_le64(MAJOR(device_number));
471 cpu_to_le64(MINOR(device_number));
472 rc = CIFSSMBWrite(xid, &io_parms,
473 &bytes_written, (char *)pdev,
475 } /* else if (S_ISFIFO) */
476 CIFSSMBClose(xid, pTcon, fileHandle);
479 /* FIXME: add code here to set EAs */
485 cifs_put_tlink(tlink);
490 cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
491 struct nameidata *nd)
494 int rc = 0; /* to get around spurious gcc warning, set to zero here */
496 __u16 fileHandle = 0;
497 bool posix_open = false;
498 struct cifs_sb_info *cifs_sb;
499 struct tcon_link *tlink;
500 struct cifs_tcon *pTcon;
501 struct cifsFileInfo *cfile;
502 struct inode *newInode = NULL;
503 char *full_path = NULL;
508 cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
509 parent_dir_inode, direntry->d_name.name, direntry);
511 /* check whether path exists */
513 cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
514 tlink = cifs_sb_tlink(cifs_sb);
517 return (struct dentry *)tlink;
519 pTcon = tlink_tcon(tlink);
522 * Don't allow the separator character in a path component.
523 * The VFS will not allow "/", but "\" is allowed by posix.
525 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
527 for (i = 0; i < direntry->d_name.len; i++)
528 if (direntry->d_name.name[i] == '\\') {
529 cFYI(1, "Invalid file name");
536 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
537 * the VFS handle the create.
539 if (nd && (nd->flags & LOOKUP_EXCL)) {
540 d_instantiate(direntry, NULL);
545 /* can not grab the rename sem here since it would
546 deadlock in the cases (beginning of sys_rename itself)
547 in which we already have the sb rename sem */
548 full_path = build_path_from_dentry(direntry);
549 if (full_path == NULL) {
554 if (direntry->d_inode != NULL) {
555 cFYI(1, "non-NULL inode in lookup");
557 cFYI(1, "NULL inode in lookup");
559 cFYI(1, "Full path: %s inode = 0x%p", full_path, direntry->d_inode);
561 /* Posix open is only called (at lookup time) for file create now.
562 * For opens (rather than creates), because we do not know if it
563 * is a file or directory yet, and current Samba no longer allows
564 * us to do posix open on dirs, we could end up wasting an open call
565 * on what turns out to be a dir. For file opens, we wait to call posix
566 * open till cifs_open. It could be added here (lookup) in the future
567 * but the performance tradeoff of the extra network request when EISDIR
568 * or EACCES is returned would have to be weighed against the 50%
569 * reduction in network traffic in the other paths.
571 if (pTcon->unix_ext) {
572 if (nd && !(nd->flags & LOOKUP_DIRECTORY) &&
573 (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
574 (nd->intent.open.file->f_flags & O_CREAT)) {
575 rc = cifs_posix_open(full_path, &newInode,
576 parent_dir_inode->i_sb,
577 nd->intent.open.create_mode,
578 nd->intent.open.file->f_flags, &oplock,
581 * The check below works around a bug in POSIX
582 * open in samba versions 3.3.1 and earlier where
583 * open could incorrectly fail with invalid parameter.
584 * If either that or op not supported returned, follow
587 if ((rc == 0) || (rc == -ENOENT))
589 else if ((rc == -EINVAL) || (rc != -EOPNOTSUPP))
590 pTcon->broken_posix_open = true;
593 rc = cifs_get_inode_info_unix(&newInode, full_path,
594 parent_dir_inode->i_sb, xid);
596 rc = cifs_get_inode_info(&newInode, full_path, NULL,
597 parent_dir_inode->i_sb, xid, NULL);
599 if ((rc == 0) && (newInode != NULL)) {
600 d_add(direntry, newInode);
602 filp = lookup_instantiate_filp(nd, direntry,
606 CIFSSMBClose(xid, pTcon, fileHandle);
610 cfile = cifs_new_fileinfo(fileHandle, filp, tlink,
614 CIFSSMBClose(xid, pTcon, fileHandle);
619 /* since paths are not looked up by component - the parent
620 directories are presumed to be good here */
621 renew_parental_timestamps(direntry);
623 } else if (rc == -ENOENT) {
625 direntry->d_time = jiffies;
626 d_add(direntry, NULL);
627 /* if it was once a directory (but how can we tell?) we could do
628 shrink_dcache_parent(direntry); */
629 } else if (rc != -EACCES) {
630 cERROR(1, "Unexpected lookup error %d", rc);
631 /* We special case check for Access Denied - since that
632 is a common return code */
637 cifs_put_tlink(tlink);
643 cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
645 if (nd && (nd->flags & LOOKUP_RCU))
648 if (direntry->d_inode) {
649 if (cifs_revalidate_dentry(direntry))
656 * This may be nfsd (or something), anyway, we can't see the
657 * intent of this. So, since this can be for creation, drop it.
663 * Drop the negative dentry, in order to make sure to use the
664 * case sensitive name which is specified by user if this is
667 if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
670 if (time_after(jiffies, direntry->d_time + HZ) || !lookupCacheEnabled)
676 /* static int cifs_d_delete(struct dentry *direntry)
680 cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
685 const struct dentry_operations cifs_dentry_ops = {
686 .d_revalidate = cifs_d_revalidate,
687 .d_automount = cifs_dfs_d_automount,
688 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
691 static int cifs_ci_hash(const struct dentry *dentry, const struct inode *inode,
694 struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
698 hash = init_name_hash();
699 for (i = 0; i < q->len; i++)
700 hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
702 q->hash = end_name_hash(hash);
707 static int cifs_ci_compare(const struct dentry *parent,
708 const struct inode *pinode,
709 const struct dentry *dentry, const struct inode *inode,
710 unsigned int len, const char *str, const struct qstr *name)
712 struct nls_table *codepage = CIFS_SB(pinode->i_sb)->local_nls;
714 if ((name->len == len) &&
715 (nls_strnicmp(codepage, name->name, str, len) == 0))
720 const struct dentry_operations cifs_ci_dentry_ops = {
721 .d_revalidate = cifs_d_revalidate,
722 .d_hash = cifs_ci_hash,
723 .d_compare = cifs_ci_compare,
724 .d_automount = cifs_dfs_d_automount,