blob: ec4e9a2a12f843edf9e8d2f60c8a32f58011ec4d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/dir.c
3 *
4 * vfs operations that deal with dentries
Steve French5fdae1f2007-06-05 18:30:44 +00005 *
Steve Frenchc3b2a0c2009-02-20 04:32:45 +00006 * Copyright (C) International Business Machines Corp., 2002,2009
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * Author(s): Steve French (sfrench@us.ibm.com)
8 *
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.
13 *
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.
18 *
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
22 */
23#include <linux/fs.h>
24#include <linux/stat.h>
25#include <linux/slab.h>
26#include <linux/namei.h>
Jeff Layton3bc303c2009-09-21 06:47:50 -040027#include <linux/mount.h>
Jeff Layton6ca9f3b2010-06-16 13:40:16 -040028#include <linux/file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "cifsfs.h"
30#include "cifspdu.h"
31#include "cifsglob.h"
32#include "cifsproto.h"
33#include "cifs_debug.h"
34#include "cifs_fs_sb.h"
35
Steve French99ee4db2007-02-27 05:35:17 +000036static void
Linus Torvalds1da177e2005-04-16 15:20:36 -070037renew_parental_timestamps(struct dentry *direntry)
38{
Steve French5fdae1f2007-06-05 18:30:44 +000039 /* BB check if there is a way to get the kernel to do this or if we
40 really need this */
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 do {
42 direntry->d_time = jiffies;
43 direntry = direntry->d_parent;
Steve French5fdae1f2007-06-05 18:30:44 +000044 } while (!IS_ROOT(direntry));
Linus Torvalds1da177e2005-04-16 15:20:36 -070045}
46
47/* Note: caller must free return buffer */
48char *
49build_path_from_dentry(struct dentry *direntry)
50{
51 struct dentry *temp;
Steve French2fe87f02006-09-21 07:02:52 +000052 int namelen;
Steve French646dd532008-05-15 01:50:56 +000053 int dfsplen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 char *full_path;
Steve French88274812006-03-09 22:21:45 +000055 char dirsep;
Jeff Layton0d424ad2010-09-20 16:01:35 -070056 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +000057 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Al Virodc137bf2011-07-16 23:37:20 -040058 unsigned seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Steve French646dd532008-05-15 01:50:56 +000060 dirsep = CIFS_DIR_SEP(cifs_sb);
Jeff Layton0d424ad2010-09-20 16:01:35 -070061 if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
62 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
Steve French646dd532008-05-15 01:50:56 +000063 else
64 dfsplen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065cifs_bp_rename_retry:
Steve Frenchf87d39d2011-05-27 03:50:55 +000066 namelen = dfsplen;
Al Virodc137bf2011-07-16 23:37:20 -040067 seq = read_seqbegin(&rename_lock);
68 rcu_read_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 for (temp = direntry; !IS_ROOT(temp);) {
70 namelen += (1 + temp->d_name.len);
71 temp = temp->d_parent;
Steve French5fdae1f2007-06-05 18:30:44 +000072 if (temp == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +000073 cERROR(1, "corrupt dentry");
Al Virodc137bf2011-07-16 23:37:20 -040074 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 return NULL;
76 }
77 }
Al Virodc137bf2011-07-16 23:37:20 -040078 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80 full_path = kmalloc(namelen+1, GFP_KERNEL);
Steve French5fdae1f2007-06-05 18:30:44 +000081 if (full_path == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 return full_path;
83 full_path[namelen] = 0; /* trailing null */
Al Virodc137bf2011-07-16 23:37:20 -040084 rcu_read_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 for (temp = direntry; !IS_ROOT(temp);) {
Al Virodc137bf2011-07-16 23:37:20 -040086 spin_lock(&temp->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 namelen -= 1 + temp->d_name.len;
88 if (namelen < 0) {
Al Virodc137bf2011-07-16 23:37:20 -040089 spin_unlock(&temp->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 break;
91 } else {
Steve French7f573562005-08-30 11:32:14 -070092 full_path[namelen] = dirsep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 strncpy(full_path + namelen + 1, temp->d_name.name,
94 temp->d_name.len);
Joe Perchesb6b38f72010-04-21 03:50:45 +000095 cFYI(0, "name: %s", full_path + namelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 }
Al Virodc137bf2011-07-16 23:37:20 -040097 spin_unlock(&temp->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 temp = temp->d_parent;
Steve French5fdae1f2007-06-05 18:30:44 +000099 if (temp == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000100 cERROR(1, "corrupt dentry");
Al Virodc137bf2011-07-16 23:37:20 -0400101 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 kfree(full_path);
103 return NULL;
104 }
105 }
Al Virodc137bf2011-07-16 23:37:20 -0400106 rcu_read_unlock();
107 if (namelen != dfsplen || read_seqretry(&rename_lock, seq)) {
Jeff Laytonfa71f442011-08-08 11:50:24 -0400108 cFYI(1, "did not end path lookup where expected. namelen=%d "
109 "dfsplen=%d", namelen, dfsplen);
Steve French5fdae1f2007-06-05 18:30:44 +0000110 /* presumably this is only possible if racing with a rename
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 of one of the parent directories (we can not lock the dentries
112 above us to prevent this, but retrying should be harmless) */
113 kfree(full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 goto cifs_bp_rename_retry;
115 }
Steve French2fe87f02006-09-21 07:02:52 +0000116 /* 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 */
Steve French646dd532008-05-15 01:50:56 +0000122
123 if (dfsplen) {
Jeff Layton0d424ad2010-09-20 16:01:35 -0700124 strncpy(full_path, tcon->treeName, dfsplen);
Steve French646dd532008-05-15 01:50:56 +0000125 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
126 int i;
127 for (i = 0; i < dfsplen; i++) {
128 if (full_path[i] == '\\')
129 full_path[i] = '/';
130 }
131 }
132 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 return full_path;
134}
135
Steve French39798772006-05-31 22:40:51 +0000136/* Inode operations in similar order to how they appear in Linux file fs.h */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
138int
Al Viro4acdaf22011-07-26 01:42:34 -0400139cifs_create(struct inode *inode, struct dentry *direntry, umode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 struct nameidata *nd)
141{
142 int rc = -ENOENT;
143 int xid;
Jeff Layton67750fb2008-05-09 22:28:02 +0000144 int create_options = CREATE_NOT_DIR;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400145 __u32 oplock = 0;
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000146 int oflags;
147 /*
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
152 * request so much.
153 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 int desiredAccess = GENERIC_READ | GENERIC_WRITE;
155 __u16 fileHandle;
156 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -0400157 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000158 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 char *full_path = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000160 FILE_ALL_INFO *buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 struct inode *newinode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 int disposition = FILE_OVERWRITE_IF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
164 xid = GetXid();
165
166 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400167 tlink = cifs_sb_tlink(cifs_sb);
168 if (IS_ERR(tlink)) {
169 FreeXid(xid);
170 return PTR_ERR(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400172 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300174 if (tcon->ses->server->oplocks)
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000175 oplock = REQ_OPLOCK;
176
Al Virodd7dd552011-06-25 21:17:17 -0400177 if (nd)
Jeff Layton608712f2010-10-15 15:33:56 -0400178 oflags = nd->intent.open.file->f_flags;
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000179 else
Jeff Layton608712f2010-10-15 15:33:56 -0400180 oflags = O_RDONLY | O_CREAT;
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000181
Jeff Layton7ffec372010-09-29 19:51:11 -0400182 full_path = build_path_from_dentry(direntry);
183 if (full_path == NULL) {
184 rc = -ENOMEM;
185 goto cifs_create_out;
186 }
187
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000188 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
189 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
190 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Steve Frenchfa588e02010-04-22 19:21:55 +0000191 rc = cifs_posix_open(full_path, &newinode,
Steve Frenchfa588e02010-04-22 19:21:55 +0000192 inode->i_sb, mode, oflags, &oplock, &fileHandle, xid);
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000193 /* EIO could indicate that (posix open) operation is not
194 supported, despite what server claimed in capability
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300195 negotiation. EREMOTE indicates DFS junction, which is not
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000196 handled in posix open */
197
Steve French90e4ee52009-05-08 03:04:30 +0000198 if (rc == 0) {
Steve French90e4ee52009-05-08 03:04:30 +0000199 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) &&
Steve French703a3b82009-05-21 22:21:53 +0000204 (rc != -EOPNOTSUPP) && (rc != -EINVAL))
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000205 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) */
210 }
Steve Frenchf818dd52009-01-19 02:38:35 +0000211
Al Virodd7dd552011-06-25 21:17:17 -0400212 if (nd) {
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000213 /* if the file is going to stay open, then we
214 need to set the desired access properly */
Miklos Szeredie08fc042005-09-06 15:18:26 -0700215 desiredAccess = 0;
Jeff Layton608712f2010-10-15 15:33:56 -0400216 if (OPEN_FMODE(oflags) & FMODE_READ)
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000217 desiredAccess |= GENERIC_READ; /* is this too little? */
Jeff Layton608712f2010-10-15 15:33:56 -0400218 if (OPEN_FMODE(oflags) & FMODE_WRITE)
Miklos Szeredie08fc042005-09-06 15:18:26 -0700219 desiredAccess |= GENERIC_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
Steve French5fdae1f2007-06-05 18:30:44 +0000221 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 disposition = FILE_CREATE;
Steve French5fdae1f2007-06-05 18:30:44 +0000223 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 disposition = FILE_OVERWRITE_IF;
Steve French5fdae1f2007-06-05 18:30:44 +0000225 else if ((oflags & O_CREAT) == O_CREAT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 disposition = FILE_OPEN_IF;
Steve Frenchad7a2922008-02-07 23:25:02 +0000227 else
Joe Perchesb6b38f72010-04-21 03:50:45 +0000228 cFYI(1, "Create flag not set in create function");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 }
230
Steve French5fdae1f2007-06-05 18:30:44 +0000231 /* BB add processing to set equivalent of mode - e.g. via CreateX with
232 ACLs */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
Steve French5fdae1f2007-06-05 18:30:44 +0000234 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
235 if (buf == NULL) {
Jeff Layton232341b2010-08-05 13:58:38 -0400236 rc = -ENOMEM;
237 goto cifs_create_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 }
Jeff Layton67750fb2008-05-09 22:28:02 +0000239
Jeff Layton67750fb2008-05-09 22:28:02 +0000240 /*
241 * if we're not using unix extensions, see if we need to set
242 * ATTR_READONLY on the create call
243 */
Steve Frenchf818dd52009-01-19 02:38:35 +0000244 if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
Jeff Layton67750fb2008-05-09 22:28:02 +0000245 create_options |= CREATE_OPTION_READONLY;
246
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500247 if (backup_cred(cifs_sb))
248 create_options |= CREATE_OPEN_BACKUP_INTENT;
249
Jeff Laytona6e8a842010-09-20 16:01:33 -0700250 if (tcon->ses->capabilities & CAP_NT_SMBS)
Steve Frenchf818dd52009-01-19 02:38:35 +0000251 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
Jeff Layton67750fb2008-05-09 22:28:02 +0000252 desiredAccess, create_options,
Steve French737b7582005-04-28 22:41:06 -0700253 &fileHandle, &oplock, buf, cifs_sb->local_nls,
254 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000255 else
256 rc = -EIO; /* no NT SMB support fall into legacy open below */
257
Steve French5fdae1f2007-06-05 18:30:44 +0000258 if (rc == -EIO) {
Steve Frencha9d02ad2005-08-24 23:06:05 -0700259 /* old server, retry the open legacy style */
Steve Frenchf818dd52009-01-19 02:38:35 +0000260 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
Jeff Layton67750fb2008-05-09 22:28:02 +0000261 desiredAccess, create_options,
Steve Frencha9d02ad2005-08-24 23:06:05 -0700262 &fileHandle, &oplock, buf, cifs_sb->local_nls,
263 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5fdae1f2007-06-05 18:30:44 +0000264 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000266 cFYI(1, "cifs_create returned 0x%x", rc);
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000267 goto cifs_create_out;
268 }
269
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 = {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400274 .mode = mode,
275 .ctime = NO_CHANGE_64,
276 .atime = NO_CHANGE_64,
277 .mtime = NO_CHANGE_64,
278 .device = 0,
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000279 };
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400280
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000281 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;
285 else
286 args.gid = (__u64) current_fsgid();
Steve French3ce53fc2007-06-08 14:55:14 +0000287 } else {
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000288 args.uid = NO_CHANGE_64;
289 args.gid = NO_CHANGE_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 }
Jeff Laytond44a9fe2011-01-07 11:30:29 -0500291 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fileHandle,
292 current->tgid);
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000293 } else {
294 /* BB implement mode setting via Windows security
295 descriptors e.g. */
296 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000298 /* Could set r/o dos attribute if mode & 0222 == 0 */
299 }
300
301cifs_create_get_file_info:
302 /* server might mask mode so we have to query for it */
303 if (tcon->unix_ext)
304 rc = cifs_get_inode_info_unix(&newinode, full_path,
305 inode->i_sb, xid);
306 else {
307 rc = cifs_get_inode_info(&newinode, full_path, buf,
308 inode->i_sb, xid, &fileHandle);
309 if (newinode) {
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;
317 else
318 newinode->i_gid = current_fsgid();
Steve French6473a552005-11-29 20:20:10 -0800319 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 }
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000321 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000323cifs_create_set_dentry:
324 if (rc == 0)
Al Viro1c929cf2010-12-18 11:43:51 -0500325 d_instantiate(direntry, newinode);
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000326 else
Joe Perchesb6b38f72010-04-21 03:50:45 +0000327 cFYI(1, "Create worked, get_inode_info failed rc = %d", rc);
Steve Frenchf818dd52009-01-19 02:38:35 +0000328
Al Virodd7dd552011-06-25 21:17:17 -0400329 if (newinode && nd) {
Suresh Jayaramanfdb36032010-05-11 09:46:46 +0530330 struct cifsFileInfo *pfile_info;
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400331 struct file *filp;
332
333 filp = lookup_instantiate_filp(nd, direntry, generic_file_open);
334 if (IS_ERR(filp)) {
335 rc = PTR_ERR(filp);
336 CIFSSMBClose(xid, tcon, fileHandle);
337 goto cifs_create_out;
338 }
339
Jeff Laytonabfe1ee2010-10-15 15:33:58 -0400340 pfile_info = cifs_new_fileinfo(fileHandle, filp, tlink, oplock);
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400341 if (pfile_info == NULL) {
342 fput(filp);
343 CIFSSMBClose(xid, tcon, fileHandle);
Suresh Jayaramanfdb36032010-05-11 09:46:46 +0530344 rc = -ENOMEM;
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400345 }
Jeff Layton2422f672010-06-16 13:40:16 -0400346 } else {
347 CIFSSMBClose(xid, tcon, fileHandle);
Steve French5fdae1f2007-06-05 18:30:44 +0000348 }
Jeff Layton2422f672010-06-16 13:40:16 -0400349
Steve Frenchd14537f12005-04-28 22:41:05 -0700350cifs_create_out:
351 kfree(buf);
352 kfree(full_path);
Jeff Layton7ffec372010-09-29 19:51:11 -0400353 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 FreeXid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 return rc;
356}
357
Al Viro1a67aaf2011-07-26 01:52:52 -0400358int cifs_mknod(struct inode *inode, struct dentry *direntry, umode_t mode,
Steve French5fdae1f2007-06-05 18:30:44 +0000359 dev_t device_number)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360{
361 int rc = -EPERM;
362 int xid;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500363 int create_options = CREATE_NOT_DIR | CREATE_OPTION_SPECIAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -0400365 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000366 struct cifs_tcon *pTcon;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +0400367 struct cifs_io_parms io_parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 char *full_path = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000369 struct inode *newinode = NULL;
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400370 int oplock = 0;
371 u16 fileHandle;
372 FILE_ALL_INFO *buf = NULL;
373 unsigned int bytes_written;
374 struct win_dev *pdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375
376 if (!old_valid_dev(device_number))
377 return -EINVAL;
378
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400380 tlink = cifs_sb_tlink(cifs_sb);
381 if (IS_ERR(tlink))
382 return PTR_ERR(tlink);
383
384 pTcon = tlink_tcon(tlink);
385
386 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 full_path = build_path_from_dentry(direntry);
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400389 if (full_path == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 rc = -ENOMEM;
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400391 goto mknod_out;
392 }
393
394 if (pTcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400395 struct cifs_unix_set_info_args args = {
Al Viroce3b0f82009-03-29 19:08:22 -0400396 .mode = mode & ~current_umask(),
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400397 .ctime = NO_CHANGE_64,
398 .atime = NO_CHANGE_64,
399 .mtime = NO_CHANGE_64,
400 .device = device_number,
401 };
Steve French5fdae1f2007-06-05 18:30:44 +0000402 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
David Howellsa001e5b2008-11-14 10:38:47 +1100403 args.uid = (__u64) current_fsuid();
404 args.gid = (__u64) current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 } else {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400406 args.uid = NO_CHANGE_64;
407 args.gid = NO_CHANGE_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 }
Jeff Layton01ea95e2009-07-09 20:02:49 -0400409 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
410 cifs_sb->local_nls,
411 cifs_sb->mnt_cifs_flags &
412 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400413 if (rc)
414 goto mknod_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400416 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve French5fdae1f2007-06-05 18:30:44 +0000417 inode->i_sb, xid);
Steve Frenchd7245c22005-07-14 18:25:12 -0500418
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400419 if (rc == 0)
420 d_instantiate(direntry, newinode);
421 goto mknod_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 }
423
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400424 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
425 goto mknod_out;
426
427
428 cFYI(1, "sfu compat create special file");
429
430 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
431 if (buf == NULL) {
432 kfree(full_path);
433 rc = -ENOMEM;
434 FreeXid(xid);
435 return rc;
436 }
437
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500438 if (backup_cred(cifs_sb))
439 create_options |= CREATE_OPEN_BACKUP_INTENT;
440
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400441 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_CREATE,
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500442 GENERIC_WRITE, create_options,
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400443 &fileHandle, &oplock, buf, cifs_sb->local_nls,
444 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
445 if (rc)
446 goto mknod_out;
447
448 /* BB Do not bother to decode buf since no local inode yet to put
449 * timestamps in, but we can reuse it safely */
450
451 pdev = (struct win_dev *)buf;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +0400452 io_parms.netfid = fileHandle;
453 io_parms.pid = current->tgid;
454 io_parms.tcon = pTcon;
455 io_parms.offset = 0;
456 io_parms.length = sizeof(struct win_dev);
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400457 if (S_ISCHR(mode)) {
458 memcpy(pdev->type, "IntxCHR", 8);
459 pdev->major =
460 cpu_to_le64(MAJOR(device_number));
461 pdev->minor =
462 cpu_to_le64(MINOR(device_number));
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +0400463 rc = CIFSSMBWrite(xid, &io_parms,
464 &bytes_written, (char *)pdev,
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400465 NULL, 0);
466 } else if (S_ISBLK(mode)) {
467 memcpy(pdev->type, "IntxBLK", 8);
468 pdev->major =
469 cpu_to_le64(MAJOR(device_number));
470 pdev->minor =
471 cpu_to_le64(MINOR(device_number));
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +0400472 rc = CIFSSMBWrite(xid, &io_parms,
473 &bytes_written, (char *)pdev,
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400474 NULL, 0);
475 } /* else if (S_ISFIFO) */
476 CIFSSMBClose(xid, pTcon, fileHandle);
477 d_drop(direntry);
478
479 /* FIXME: add code here to set EAs */
480
481mknod_out:
Steve Frenchd14537f12005-04-28 22:41:05 -0700482 kfree(full_path);
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400483 kfree(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400485 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 return rc;
487}
488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489struct dentry *
Steve French5fdae1f2007-06-05 18:30:44 +0000490cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
491 struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492{
493 int xid;
494 int rc = 0; /* to get around spurious gcc warning, set to zero here */
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300495 __u32 oplock;
Steve Frencha6ce4932009-04-09 01:14:32 +0000496 __u16 fileHandle = 0;
497 bool posix_open = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -0400499 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000500 struct cifs_tcon *pTcon;
Jeff Layton2422f672010-06-16 13:40:16 -0400501 struct cifsFileInfo *cfile;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 struct inode *newInode = NULL;
503 char *full_path = NULL;
Steve Frencha6ce4932009-04-09 01:14:32 +0000504 struct file *filp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
506 xid = GetXid();
507
Joe Perchesb6b38f72010-04-21 03:50:45 +0000508 cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
509 parent_dir_inode, direntry->d_name.name, direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 /* check whether path exists */
512
513 cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400514 tlink = cifs_sb_tlink(cifs_sb);
515 if (IS_ERR(tlink)) {
516 FreeXid(xid);
517 return (struct dentry *)tlink;
518 }
519 pTcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300521 oplock = pTcon->ses->server->oplocks ? REQ_OPLOCK : 0;
522
Steve French296034f2006-04-21 18:18:37 +0000523 /*
524 * Don't allow the separator character in a path component.
525 * The VFS will not allow "/", but "\" is allowed by posix.
526 */
527 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
528 int i;
529 for (i = 0; i < direntry->d_name.len; i++)
530 if (direntry->d_name.name[i] == '\\') {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000531 cFYI(1, "Invalid file name");
Jeff Layton7ffec372010-09-29 19:51:11 -0400532 rc = -EINVAL;
533 goto lookup_out;
Steve French296034f2006-04-21 18:18:37 +0000534 }
535 }
536
Jeff Layton5ddf1e02009-07-05 11:01:02 -0400537 /*
538 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
539 * the VFS handle the create.
540 */
Steve French8e6c0332009-11-24 22:17:59 +0000541 if (nd && (nd->flags & LOOKUP_EXCL)) {
Jeff Layton5ddf1e02009-07-05 11:01:02 -0400542 d_instantiate(direntry, NULL);
Jeff Layton7ffec372010-09-29 19:51:11 -0400543 rc = 0;
544 goto lookup_out;
Jeff Layton5ddf1e02009-07-05 11:01:02 -0400545 }
546
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 /* can not grab the rename sem here since it would
548 deadlock in the cases (beginning of sys_rename itself)
549 in which we already have the sb rename sem */
550 full_path = build_path_from_dentry(direntry);
Steve French5fdae1f2007-06-05 18:30:44 +0000551 if (full_path == NULL) {
Jeff Layton7ffec372010-09-29 19:51:11 -0400552 rc = -ENOMEM;
553 goto lookup_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 }
555
556 if (direntry->d_inode != NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000557 cFYI(1, "non-NULL inode in lookup");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000559 cFYI(1, "NULL inode in lookup");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000561 cFYI(1, "Full path: %s inode = 0x%p", full_path, direntry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
Steve French8db14ca2009-05-23 18:57:25 +0000563 /* Posix open is only called (at lookup time) for file create now.
564 * For opens (rather than creates), because we do not know if it
565 * is a file or directory yet, and current Samba no longer allows
566 * us to do posix open on dirs, we could end up wasting an open call
567 * on what turns out to be a dir. For file opens, we wait to call posix
568 * open till cifs_open. It could be added here (lookup) in the future
569 * but the performance tradeoff of the extra network request when EISDIR
570 * or EACCES is returned would have to be weighed against the 50%
571 * reduction in network traffic in the other paths.
572 */
Steve Frencha6ce4932009-04-09 01:14:32 +0000573 if (pTcon->unix_ext) {
Al Viro43527802011-06-25 21:45:21 -0400574 if (nd && !(nd->flags & LOOKUP_DIRECTORY) &&
Steve French8db14ca2009-05-23 18:57:25 +0000575 (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
Jeff Layton608712f2010-10-15 15:33:56 -0400576 (nd->intent.open.file->f_flags & O_CREAT)) {
Jeff Layton2422f672010-06-16 13:40:16 -0400577 rc = cifs_posix_open(full_path, &newInode,
Steve Frenchfa588e02010-04-22 19:21:55 +0000578 parent_dir_inode->i_sb,
Steve French703a3b82009-05-21 22:21:53 +0000579 nd->intent.open.create_mode,
Jeff Layton608712f2010-10-15 15:33:56 -0400580 nd->intent.open.file->f_flags, &oplock,
Steve Frencha6ce4932009-04-09 01:14:32 +0000581 &fileHandle, xid);
Steve French8db14ca2009-05-23 18:57:25 +0000582 /*
583 * The check below works around a bug in POSIX
584 * open in samba versions 3.3.1 and earlier where
585 * open could incorrectly fail with invalid parameter.
586 * If either that or op not supported returned, follow
587 * the normal lookup.
588 */
Jeff Layton5bccda02012-02-23 09:37:45 -0500589 switch (rc) {
590 case 0:
591 /*
592 * The server may allow us to open things like
593 * FIFOs, but the client isn't set up to deal
594 * with that. If it's not a regular file, just
595 * close it and proceed as if it were a normal
596 * lookup.
597 */
598 if (newInode && !S_ISREG(newInode->i_mode)) {
599 CIFSSMBClose(xid, pTcon, fileHandle);
600 break;
601 }
602 case -ENOENT:
Steve French8db14ca2009-05-23 18:57:25 +0000603 posix_open = true;
Jeff Layton5bccda02012-02-23 09:37:45 -0500604 case -EOPNOTSUPP:
605 break;
606 default:
Steve French8db14ca2009-05-23 18:57:25 +0000607 pTcon->broken_posix_open = true;
Jeff Layton5bccda02012-02-23 09:37:45 -0500608 }
Steve Frencha6ce4932009-04-09 01:14:32 +0000609 }
610 if (!posix_open)
611 rc = cifs_get_inode_info_unix(&newInode, full_path,
612 parent_dir_inode->i_sb, xid);
613 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 rc = cifs_get_inode_info(&newInode, full_path, NULL,
Steve Frencha6ce4932009-04-09 01:14:32 +0000615 parent_dir_inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 if ((rc == 0) && (newInode != NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 d_add(direntry, newInode);
Jeff Layton2422f672010-06-16 13:40:16 -0400619 if (posix_open) {
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400620 filp = lookup_instantiate_filp(nd, direntry,
621 generic_file_open);
622 if (IS_ERR(filp)) {
623 rc = PTR_ERR(filp);
624 CIFSSMBClose(xid, pTcon, fileHandle);
625 goto lookup_out;
626 }
627
Jeff Laytonabfe1ee2010-10-15 15:33:58 -0400628 cfile = cifs_new_fileinfo(fileHandle, filp, tlink,
629 oplock);
Jeff Layton2422f672010-06-16 13:40:16 -0400630 if (cfile == NULL) {
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400631 fput(filp);
Jeff Layton2422f672010-06-16 13:40:16 -0400632 CIFSSMBClose(xid, pTcon, fileHandle);
633 rc = -ENOMEM;
634 goto lookup_out;
635 }
Jeff Layton2422f672010-06-16 13:40:16 -0400636 }
Steve French5fdae1f2007-06-05 18:30:44 +0000637 /* since paths are not looked up by component - the parent
Steve French3abb9272005-11-28 08:16:13 -0800638 directories are presumed to be good here */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 renew_parental_timestamps(direntry);
640
641 } else if (rc == -ENOENT) {
642 rc = 0;
Steve French3abb9272005-11-28 08:16:13 -0800643 direntry->d_time = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 d_add(direntry, NULL);
Steve French5fdae1f2007-06-05 18:30:44 +0000645 /* if it was once a directory (but how can we tell?) we could do
646 shrink_dcache_parent(direntry); */
Steve Frenched2b9172008-01-20 00:30:29 +0000647 } else if (rc != -EACCES) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000648 cERROR(1, "Unexpected lookup error %d", rc);
Steve Frenched2b9172008-01-20 00:30:29 +0000649 /* We special case check for Access Denied - since that
650 is a common return code */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 }
652
Jeff Layton2422f672010-06-16 13:40:16 -0400653lookup_out:
Steve Frenchd14537f12005-04-28 22:41:05 -0700654 kfree(full_path);
Jeff Layton7ffec372010-09-29 19:51:11 -0400655 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 FreeXid(xid);
657 return ERR_PTR(rc);
658}
659
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660static int
661cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
662{
Pavel Shilovsky3ca30d42011-07-25 17:59:10 +0400663 if (nd && (nd->flags & LOOKUP_RCU))
Nick Piggin34286d62011-01-07 17:49:57 +1100664 return -ECHILD;
665
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 if (direntry->d_inode) {
Jeff Laytondf2cf172010-02-12 07:44:16 -0500667 if (cifs_revalidate_dentry(direntry))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 return 0;
Gerlando Falautoad4778f2011-10-18 10:58:50 +0200669 else {
670 /*
Ian Kent936ad902012-05-02 07:19:09 -0400671 * If the inode wasn't known to be a dfs entry when
672 * the dentry was instantiated, such as when created
673 * via ->readdir(), it needs to be set now since the
674 * attributes will have been updated by
675 * cifs_revalidate_dentry().
Gerlando Falautoad4778f2011-10-18 10:58:50 +0200676 */
Ian Kent936ad902012-05-02 07:19:09 -0400677 if (IS_AUTOMOUNT(direntry->d_inode) &&
678 !(direntry->d_flags & DCACHE_NEED_AUTOMOUNT)) {
679 spin_lock(&direntry->d_lock);
680 direntry->d_flags |= DCACHE_NEED_AUTOMOUNT;
681 spin_unlock(&direntry->d_lock);
682 }
683
Nick Piggin262f86a2010-11-11 18:42:16 +1100684 return 1;
Gerlando Falautoad4778f2011-10-18 10:58:50 +0200685 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 }
687
Nick Piggin262f86a2010-11-11 18:42:16 +1100688 /*
689 * This may be nfsd (or something), anyway, we can't see the
690 * intent of this. So, since this can be for creation, drop it.
691 */
692 if (!nd)
693 return 0;
694
695 /*
696 * Drop the negative dentry, in order to make sure to use the
697 * case sensitive name which is specified by user if this is
698 * for creation.
699 */
Al Viro407938e2011-06-25 21:37:18 -0400700 if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
701 return 0;
Nick Piggin262f86a2010-11-11 18:42:16 +1100702
703 if (time_after(jiffies, direntry->d_time + HZ) || !lookupCacheEnabled)
704 return 0;
705
706 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707}
708
709/* static int cifs_d_delete(struct dentry *direntry)
710{
711 int rc = 0;
712
Joe Perchesb6b38f72010-04-21 03:50:45 +0000713 cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
715 return rc;
716} */
717
Al Viro4fd03e82009-02-20 05:57:07 +0000718const struct dentry_operations cifs_dentry_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 .d_revalidate = cifs_d_revalidate,
David Howells01c64fe2011-01-14 18:45:47 +0000720 .d_automount = cifs_dfs_d_automount,
Steve French5fdae1f2007-06-05 18:30:44 +0000721/* d_delete: cifs_d_delete, */ /* not needed except for debugging */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722};
Steve Frenchb92327f2005-08-22 20:09:43 -0700723
Nick Pigginb1e6a012011-01-07 17:49:28 +1100724static int cifs_ci_hash(const struct dentry *dentry, const struct inode *inode,
725 struct qstr *q)
Steve Frenchb92327f2005-08-22 20:09:43 -0700726{
Nick Pigginb1e6a012011-01-07 17:49:28 +1100727 struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
Steve Frenchb92327f2005-08-22 20:09:43 -0700728 unsigned long hash;
729 int i;
730
731 hash = init_name_hash();
732 for (i = 0; i < q->len; i++)
733 hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
734 hash);
735 q->hash = end_name_hash(hash);
736
737 return 0;
738}
739
Nick Piggin621e1552011-01-07 17:49:27 +1100740static int cifs_ci_compare(const struct dentry *parent,
741 const struct inode *pinode,
742 const struct dentry *dentry, const struct inode *inode,
743 unsigned int len, const char *str, const struct qstr *name)
Steve Frenchb92327f2005-08-22 20:09:43 -0700744{
Nick Piggin621e1552011-01-07 17:49:27 +1100745 struct nls_table *codepage = CIFS_SB(pinode->i_sb)->local_nls;
Steve Frenchb92327f2005-08-22 20:09:43 -0700746
Nick Piggin621e1552011-01-07 17:49:27 +1100747 if ((name->len == len) &&
748 (nls_strnicmp(codepage, name->name, str, len) == 0))
Steve Frenchb92327f2005-08-22 20:09:43 -0700749 return 0;
Steve Frenchb92327f2005-08-22 20:09:43 -0700750 return 1;
751}
752
Al Viro4fd03e82009-02-20 05:57:07 +0000753const struct dentry_operations cifs_ci_dentry_ops = {
Steve Frenchb92327f2005-08-22 20:09:43 -0700754 .d_revalidate = cifs_d_revalidate,
755 .d_hash = cifs_ci_hash,
756 .d_compare = cifs_ci_compare,
David Howells01c64fe2011-01-14 18:45:47 +0000757 .d_automount = cifs_dfs_d_automount,
Steve Frenchb92327f2005-08-22 20:09:43 -0700758};