blob: dd5f22918c33ae2cdde0dd15d2d93a381255a51b [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;
53 int pplen;
Steve French646dd532008-05-15 01:50:56 +000054 int dfsplen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 char *full_path;
Steve French88274812006-03-09 22:21:45 +000056 char dirsep;
Jeff Layton0d424ad2010-09-20 16:01:35 -070057 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
58 struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Steve French5fdae1f2007-06-05 18:30:44 +000060 if (direntry == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 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 */
64
Steve French646dd532008-05-15 01:50:56 +000065 dirsep = CIFS_DIR_SEP(cifs_sb);
66 pplen = cifs_sb->prepathlen;
Jeff Layton0d424ad2010-09-20 16:01:35 -070067 if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
68 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
Steve French646dd532008-05-15 01:50:56 +000069 else
70 dfsplen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070071cifs_bp_rename_retry:
Steve French646dd532008-05-15 01:50:56 +000072 namelen = pplen + dfsplen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 for (temp = direntry; !IS_ROOT(temp);) {
74 namelen += (1 + temp->d_name.len);
75 temp = temp->d_parent;
Steve French5fdae1f2007-06-05 18:30:44 +000076 if (temp == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +000077 cERROR(1, "corrupt dentry");
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 return NULL;
79 }
80 }
81
82 full_path = kmalloc(namelen+1, GFP_KERNEL);
Steve French5fdae1f2007-06-05 18:30:44 +000083 if (full_path == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 return full_path;
85 full_path[namelen] = 0; /* trailing null */
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 for (temp = direntry; !IS_ROOT(temp);) {
87 namelen -= 1 + temp->d_name.len;
88 if (namelen < 0) {
89 break;
90 } else {
Steve French7f573562005-08-30 11:32:14 -070091 full_path[namelen] = dirsep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 strncpy(full_path + namelen + 1, temp->d_name.name,
93 temp->d_name.len);
Joe Perchesb6b38f72010-04-21 03:50:45 +000094 cFYI(0, "name: %s", full_path + namelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 }
96 temp = temp->d_parent;
Steve French5fdae1f2007-06-05 18:30:44 +000097 if (temp == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +000098 cERROR(1, "corrupt dentry");
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 kfree(full_path);
100 return NULL;
101 }
102 }
Steve French646dd532008-05-15 01:50:56 +0000103 if (namelen != pplen + dfsplen) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000104 cERROR(1, "did not end path lookup where expected namelen is %d",
105 namelen);
Steve French5fdae1f2007-06-05 18:30:44 +0000106 /* presumably this is only possible if racing with a rename
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 of one of the parent directories (we can not lock the dentries
108 above us to prevent this, but retrying should be harmless) */
109 kfree(full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 goto cifs_bp_rename_retry;
111 }
Steve French2fe87f02006-09-21 07:02:52 +0000112 /* 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 */
Steve French646dd532008-05-15 01:50:56 +0000118
119 if (dfsplen) {
Jeff Layton0d424ad2010-09-20 16:01:35 -0700120 strncpy(full_path, tcon->treeName, dfsplen);
Steve French646dd532008-05-15 01:50:56 +0000121 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
122 int i;
123 for (i = 0; i < dfsplen; i++) {
124 if (full_path[i] == '\\')
125 full_path[i] = '/';
126 }
127 }
128 }
129 strncpy(full_path + dfsplen, CIFS_SB(direntry->d_sb)->prepath, pplen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 return full_path;
131}
132
Steve French39798772006-05-31 22:40:51 +0000133/* Inode operations in similar order to how they appear in Linux file fs.h */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
135int
136cifs_create(struct inode *inode, struct dentry *direntry, int mode,
137 struct nameidata *nd)
138{
139 int rc = -ENOENT;
140 int xid;
Jeff Layton67750fb2008-05-09 22:28:02 +0000141 int create_options = CREATE_NOT_DIR;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400142 __u32 oplock = 0;
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000143 int oflags;
144 /*
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
149 * request so much.
150 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 int desiredAccess = GENERIC_READ | GENERIC_WRITE;
152 __u16 fileHandle;
153 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -0400154 struct tcon_link *tlink;
Steve Frenchf818dd52009-01-19 02:38:35 +0000155 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 char *full_path = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000157 FILE_ALL_INFO *buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 struct inode *newinode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 int disposition = FILE_OVERWRITE_IF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
161 xid = GetXid();
162
163 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400164 tlink = cifs_sb_tlink(cifs_sb);
165 if (IS_ERR(tlink)) {
166 FreeXid(xid);
167 return PTR_ERR(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400169 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000171 if (oplockEnabled)
172 oplock = REQ_OPLOCK;
173
174 if (nd && (nd->flags & LOOKUP_OPEN))
Jeff Layton608712f2010-10-15 15:33:56 -0400175 oflags = nd->intent.open.file->f_flags;
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000176 else
Jeff Layton608712f2010-10-15 15:33:56 -0400177 oflags = O_RDONLY | O_CREAT;
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000178
Jeff Layton7ffec372010-09-29 19:51:11 -0400179 full_path = build_path_from_dentry(direntry);
180 if (full_path == NULL) {
181 rc = -ENOMEM;
182 goto cifs_create_out;
183 }
184
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000185 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
186 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
187 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Steve Frenchfa588e02010-04-22 19:21:55 +0000188 rc = cifs_posix_open(full_path, &newinode,
Steve Frenchfa588e02010-04-22 19:21:55 +0000189 inode->i_sb, mode, oflags, &oplock, &fileHandle, xid);
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000190 /* 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 */
194
Steve French90e4ee52009-05-08 03:04:30 +0000195 if (rc == 0) {
Steve French90e4ee52009-05-08 03:04:30 +0000196 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) &&
Steve French703a3b82009-05-21 22:21:53 +0000201 (rc != -EOPNOTSUPP) && (rc != -EINVAL))
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000202 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) */
207 }
Steve Frenchf818dd52009-01-19 02:38:35 +0000208
Steve French5fdae1f2007-06-05 18:30:44 +0000209 if (nd && (nd->flags & LOOKUP_OPEN)) {
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000210 /* if the file is going to stay open, then we
211 need to set the desired access properly */
Miklos Szeredie08fc042005-09-06 15:18:26 -0700212 desiredAccess = 0;
Jeff Layton608712f2010-10-15 15:33:56 -0400213 if (OPEN_FMODE(oflags) & FMODE_READ)
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000214 desiredAccess |= GENERIC_READ; /* is this too little? */
Jeff Layton608712f2010-10-15 15:33:56 -0400215 if (OPEN_FMODE(oflags) & FMODE_WRITE)
Miklos Szeredie08fc042005-09-06 15:18:26 -0700216 desiredAccess |= GENERIC_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
Steve French5fdae1f2007-06-05 18:30:44 +0000218 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 disposition = FILE_CREATE;
Steve French5fdae1f2007-06-05 18:30:44 +0000220 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 disposition = FILE_OVERWRITE_IF;
Steve French5fdae1f2007-06-05 18:30:44 +0000222 else if ((oflags & O_CREAT) == O_CREAT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 disposition = FILE_OPEN_IF;
Steve Frenchad7a2922008-02-07 23:25:02 +0000224 else
Joe Perchesb6b38f72010-04-21 03:50:45 +0000225 cFYI(1, "Create flag not set in create function");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 }
227
Steve French5fdae1f2007-06-05 18:30:44 +0000228 /* BB add processing to set equivalent of mode - e.g. via CreateX with
229 ACLs */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
Steve French5fdae1f2007-06-05 18:30:44 +0000231 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
232 if (buf == NULL) {
Jeff Layton232341b2010-08-05 13:58:38 -0400233 rc = -ENOMEM;
234 goto cifs_create_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 }
Jeff Layton67750fb2008-05-09 22:28:02 +0000236
Jeff Layton67750fb2008-05-09 22:28:02 +0000237 /*
238 * if we're not using unix extensions, see if we need to set
239 * ATTR_READONLY on the create call
240 */
Steve Frenchf818dd52009-01-19 02:38:35 +0000241 if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
Jeff Layton67750fb2008-05-09 22:28:02 +0000242 create_options |= CREATE_OPTION_READONLY;
243
Jeff Laytona6e8a842010-09-20 16:01:33 -0700244 if (tcon->ses->capabilities & CAP_NT_SMBS)
Steve Frenchf818dd52009-01-19 02:38:35 +0000245 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
Jeff Layton67750fb2008-05-09 22:28:02 +0000246 desiredAccess, create_options,
Steve French737b7582005-04-28 22:41:06 -0700247 &fileHandle, &oplock, buf, cifs_sb->local_nls,
248 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000249 else
250 rc = -EIO; /* no NT SMB support fall into legacy open below */
251
Steve French5fdae1f2007-06-05 18:30:44 +0000252 if (rc == -EIO) {
Steve Frencha9d02ad2005-08-24 23:06:05 -0700253 /* old server, retry the open legacy style */
Steve Frenchf818dd52009-01-19 02:38:35 +0000254 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
Jeff Layton67750fb2008-05-09 22:28:02 +0000255 desiredAccess, create_options,
Steve Frencha9d02ad2005-08-24 23:06:05 -0700256 &fileHandle, &oplock, buf, cifs_sb->local_nls,
257 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5fdae1f2007-06-05 18:30:44 +0000258 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000260 cFYI(1, "cifs_create returned 0x%x", rc);
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000261 goto cifs_create_out;
262 }
263
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 = {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400268 .mode = mode,
269 .ctime = NO_CHANGE_64,
270 .atime = NO_CHANGE_64,
271 .mtime = NO_CHANGE_64,
272 .device = 0,
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000273 };
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400274
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000275 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;
279 else
280 args.gid = (__u64) current_fsgid();
Steve French3ce53fc2007-06-08 14:55:14 +0000281 } else {
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000282 args.uid = NO_CHANGE_64;
283 args.gid = NO_CHANGE_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 }
Jeff Laytond44a9fe2011-01-07 11:30:29 -0500285 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fileHandle,
286 current->tgid);
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000287 } else {
288 /* BB implement mode setting via Windows security
289 descriptors e.g. */
290 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000292 /* Could set r/o dos attribute if mode & 0222 == 0 */
293 }
294
295cifs_create_get_file_info:
296 /* server might mask mode so we have to query for it */
297 if (tcon->unix_ext)
298 rc = cifs_get_inode_info_unix(&newinode, full_path,
299 inode->i_sb, xid);
300 else {
301 rc = cifs_get_inode_info(&newinode, full_path, buf,
302 inode->i_sb, xid, &fileHandle);
303 if (newinode) {
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;
311 else
312 newinode->i_gid = current_fsgid();
Steve French6473a552005-11-29 20:20:10 -0800313 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 }
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000315 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000317cifs_create_set_dentry:
318 if (rc == 0)
Al Viro1c929cf2010-12-18 11:43:51 -0500319 d_instantiate(direntry, newinode);
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000320 else
Joe Perchesb6b38f72010-04-21 03:50:45 +0000321 cFYI(1, "Create worked, get_inode_info failed rc = %d", rc);
Steve Frenchf818dd52009-01-19 02:38:35 +0000322
Jeff Layton2422f672010-06-16 13:40:16 -0400323 if (newinode && nd && (nd->flags & LOOKUP_OPEN)) {
Suresh Jayaramanfdb36032010-05-11 09:46:46 +0530324 struct cifsFileInfo *pfile_info;
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400325 struct file *filp;
326
327 filp = lookup_instantiate_filp(nd, direntry, generic_file_open);
328 if (IS_ERR(filp)) {
329 rc = PTR_ERR(filp);
330 CIFSSMBClose(xid, tcon, fileHandle);
331 goto cifs_create_out;
332 }
333
Jeff Laytonabfe1ee2010-10-15 15:33:58 -0400334 pfile_info = cifs_new_fileinfo(fileHandle, filp, tlink, oplock);
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400335 if (pfile_info == NULL) {
336 fput(filp);
337 CIFSSMBClose(xid, tcon, fileHandle);
Suresh Jayaramanfdb36032010-05-11 09:46:46 +0530338 rc = -ENOMEM;
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400339 }
Jeff Layton2422f672010-06-16 13:40:16 -0400340 } else {
341 CIFSSMBClose(xid, tcon, fileHandle);
Steve French5fdae1f2007-06-05 18:30:44 +0000342 }
Jeff Layton2422f672010-06-16 13:40:16 -0400343
Steve Frenchd14537f12005-04-28 22:41:05 -0700344cifs_create_out:
345 kfree(buf);
346 kfree(full_path);
Jeff Layton7ffec372010-09-29 19:51:11 -0400347 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 FreeXid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 return rc;
350}
351
Steve French5fdae1f2007-06-05 18:30:44 +0000352int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
353 dev_t device_number)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354{
355 int rc = -EPERM;
356 int xid;
357 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -0400358 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 struct cifsTconInfo *pTcon;
360 char *full_path = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000361 struct inode *newinode = NULL;
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400362 int oplock = 0;
363 u16 fileHandle;
364 FILE_ALL_INFO *buf = NULL;
365 unsigned int bytes_written;
366 struct win_dev *pdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
368 if (!old_valid_dev(device_number))
369 return -EINVAL;
370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400372 tlink = cifs_sb_tlink(cifs_sb);
373 if (IS_ERR(tlink))
374 return PTR_ERR(tlink);
375
376 pTcon = tlink_tcon(tlink);
377
378 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 full_path = build_path_from_dentry(direntry);
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400381 if (full_path == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 rc = -ENOMEM;
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400383 goto mknod_out;
384 }
385
386 if (pTcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400387 struct cifs_unix_set_info_args args = {
Al Viroce3b0f82009-03-29 19:08:22 -0400388 .mode = mode & ~current_umask(),
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400389 .ctime = NO_CHANGE_64,
390 .atime = NO_CHANGE_64,
391 .mtime = NO_CHANGE_64,
392 .device = device_number,
393 };
Steve French5fdae1f2007-06-05 18:30:44 +0000394 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
David Howellsa001e5b2008-11-14 10:38:47 +1100395 args.uid = (__u64) current_fsuid();
396 args.gid = (__u64) current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 } else {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400398 args.uid = NO_CHANGE_64;
399 args.gid = NO_CHANGE_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 }
Jeff Layton01ea95e2009-07-09 20:02:49 -0400401 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
402 cifs_sb->local_nls,
403 cifs_sb->mnt_cifs_flags &
404 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400405 if (rc)
406 goto mknod_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400408 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve French5fdae1f2007-06-05 18:30:44 +0000409 inode->i_sb, xid);
Steve Frenchd7245c22005-07-14 18:25:12 -0500410
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400411 if (rc == 0)
412 d_instantiate(direntry, newinode);
413 goto mknod_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 }
415
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400416 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
417 goto mknod_out;
418
419
420 cFYI(1, "sfu compat create special file");
421
422 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
423 if (buf == NULL) {
424 kfree(full_path);
425 rc = -ENOMEM;
426 FreeXid(xid);
427 return rc;
428 }
429
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);
435 if (rc)
436 goto mknod_out;
437
438 /* BB Do not bother to decode buf since no local inode yet to put
439 * timestamps in, but we can reuse it safely */
440
441 pdev = (struct win_dev *)buf;
442 if (S_ISCHR(mode)) {
443 memcpy(pdev->type, "IntxCHR", 8);
444 pdev->major =
445 cpu_to_le64(MAJOR(device_number));
446 pdev->minor =
447 cpu_to_le64(MINOR(device_number));
448 rc = CIFSSMBWrite(xid, pTcon,
449 fileHandle,
450 sizeof(struct win_dev),
451 0, &bytes_written, (char *)pdev,
452 NULL, 0);
453 } else if (S_ISBLK(mode)) {
454 memcpy(pdev->type, "IntxBLK", 8);
455 pdev->major =
456 cpu_to_le64(MAJOR(device_number));
457 pdev->minor =
458 cpu_to_le64(MINOR(device_number));
459 rc = CIFSSMBWrite(xid, pTcon,
460 fileHandle,
461 sizeof(struct win_dev),
462 0, &bytes_written, (char *)pdev,
463 NULL, 0);
464 } /* else if (S_ISFIFO) */
465 CIFSSMBClose(xid, pTcon, fileHandle);
466 d_drop(direntry);
467
468 /* FIXME: add code here to set EAs */
469
470mknod_out:
Steve Frenchd14537f12005-04-28 22:41:05 -0700471 kfree(full_path);
Jeff Layton5d9ac7f2010-08-05 13:58:22 -0400472 kfree(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400474 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 return rc;
476}
477
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478struct dentry *
Steve French5fdae1f2007-06-05 18:30:44 +0000479cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
480 struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481{
482 int xid;
483 int rc = 0; /* to get around spurious gcc warning, set to zero here */
Jeff Layton590a3fe2009-09-12 11:54:28 -0400484 __u32 oplock = 0;
Steve Frencha6ce4932009-04-09 01:14:32 +0000485 __u16 fileHandle = 0;
486 bool posix_open = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 struct cifs_sb_info *cifs_sb;
Jeff Layton7ffec372010-09-29 19:51:11 -0400488 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 struct cifsTconInfo *pTcon;
Jeff Layton2422f672010-06-16 13:40:16 -0400490 struct cifsFileInfo *cfile;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 struct inode *newInode = NULL;
492 char *full_path = NULL;
Steve Frencha6ce4932009-04-09 01:14:32 +0000493 struct file *filp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
495 xid = GetXid();
496
Joe Perchesb6b38f72010-04-21 03:50:45 +0000497 cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
498 parent_dir_inode, direntry->d_name.name, direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 /* check whether path exists */
501
502 cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400503 tlink = cifs_sb_tlink(cifs_sb);
504 if (IS_ERR(tlink)) {
505 FreeXid(xid);
506 return (struct dentry *)tlink;
507 }
508 pTcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
Steve French296034f2006-04-21 18:18:37 +0000510 /*
511 * Don't allow the separator character in a path component.
512 * The VFS will not allow "/", but "\" is allowed by posix.
513 */
514 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
515 int i;
516 for (i = 0; i < direntry->d_name.len; i++)
517 if (direntry->d_name.name[i] == '\\') {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000518 cFYI(1, "Invalid file name");
Jeff Layton7ffec372010-09-29 19:51:11 -0400519 rc = -EINVAL;
520 goto lookup_out;
Steve French296034f2006-04-21 18:18:37 +0000521 }
522 }
523
Jeff Layton5ddf1e02009-07-05 11:01:02 -0400524 /*
525 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
526 * the VFS handle the create.
527 */
Steve French8e6c0332009-11-24 22:17:59 +0000528 if (nd && (nd->flags & LOOKUP_EXCL)) {
Jeff Layton5ddf1e02009-07-05 11:01:02 -0400529 d_instantiate(direntry, NULL);
Jeff Layton7ffec372010-09-29 19:51:11 -0400530 rc = 0;
531 goto lookup_out;
Jeff Layton5ddf1e02009-07-05 11:01:02 -0400532 }
533
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 /* 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);
Steve French5fdae1f2007-06-05 18:30:44 +0000538 if (full_path == NULL) {
Jeff Layton7ffec372010-09-29 19:51:11 -0400539 rc = -ENOMEM;
540 goto lookup_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 }
542
543 if (direntry->d_inode != NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000544 cFYI(1, "non-NULL inode in lookup");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000546 cFYI(1, "NULL inode in lookup");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000548 cFYI(1, "Full path: %s inode = 0x%p", full_path, direntry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
Steve French8db14ca2009-05-23 18:57:25 +0000550 /* 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.
559 */
Steve Frencha6ce4932009-04-09 01:14:32 +0000560 if (pTcon->unix_ext) {
Steve French8e6c0332009-11-24 22:17:59 +0000561 if (nd && !(nd->flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY)) &&
Steve French8db14ca2009-05-23 18:57:25 +0000562 (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
Jeff Layton608712f2010-10-15 15:33:56 -0400563 (nd->intent.open.file->f_flags & O_CREAT)) {
Jeff Layton2422f672010-06-16 13:40:16 -0400564 rc = cifs_posix_open(full_path, &newInode,
Steve Frenchfa588e02010-04-22 19:21:55 +0000565 parent_dir_inode->i_sb,
Steve French703a3b82009-05-21 22:21:53 +0000566 nd->intent.open.create_mode,
Jeff Layton608712f2010-10-15 15:33:56 -0400567 nd->intent.open.file->f_flags, &oplock,
Steve Frencha6ce4932009-04-09 01:14:32 +0000568 &fileHandle, xid);
Steve French8db14ca2009-05-23 18:57:25 +0000569 /*
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
574 * the normal lookup.
575 */
576 if ((rc == 0) || (rc == -ENOENT))
577 posix_open = true;
578 else if ((rc == -EINVAL) || (rc != -EOPNOTSUPP))
579 pTcon->broken_posix_open = true;
Steve Frencha6ce4932009-04-09 01:14:32 +0000580 }
581 if (!posix_open)
582 rc = cifs_get_inode_info_unix(&newInode, full_path,
583 parent_dir_inode->i_sb, xid);
584 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 rc = cifs_get_inode_info(&newInode, full_path, NULL,
Steve Frencha6ce4932009-04-09 01:14:32 +0000586 parent_dir_inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
588 if ((rc == 0) && (newInode != NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 d_add(direntry, newInode);
Jeff Layton2422f672010-06-16 13:40:16 -0400590 if (posix_open) {
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400591 filp = lookup_instantiate_filp(nd, direntry,
592 generic_file_open);
593 if (IS_ERR(filp)) {
594 rc = PTR_ERR(filp);
595 CIFSSMBClose(xid, pTcon, fileHandle);
596 goto lookup_out;
597 }
598
Jeff Laytonabfe1ee2010-10-15 15:33:58 -0400599 cfile = cifs_new_fileinfo(fileHandle, filp, tlink,
600 oplock);
Jeff Layton2422f672010-06-16 13:40:16 -0400601 if (cfile == NULL) {
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400602 fput(filp);
Jeff Layton2422f672010-06-16 13:40:16 -0400603 CIFSSMBClose(xid, pTcon, fileHandle);
604 rc = -ENOMEM;
605 goto lookup_out;
606 }
Jeff Layton2422f672010-06-16 13:40:16 -0400607 }
Steve French5fdae1f2007-06-05 18:30:44 +0000608 /* since paths are not looked up by component - the parent
Steve French3abb9272005-11-28 08:16:13 -0800609 directories are presumed to be good here */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 renew_parental_timestamps(direntry);
611
612 } else if (rc == -ENOENT) {
613 rc = 0;
Steve French3abb9272005-11-28 08:16:13 -0800614 direntry->d_time = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 d_add(direntry, NULL);
Steve French5fdae1f2007-06-05 18:30:44 +0000616 /* if it was once a directory (but how can we tell?) we could do
617 shrink_dcache_parent(direntry); */
Steve Frenched2b9172008-01-20 00:30:29 +0000618 } else if (rc != -EACCES) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000619 cERROR(1, "Unexpected lookup error %d", rc);
Steve Frenched2b9172008-01-20 00:30:29 +0000620 /* We special case check for Access Denied - since that
621 is a common return code */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 }
623
Jeff Layton2422f672010-06-16 13:40:16 -0400624lookup_out:
Steve Frenchd14537f12005-04-28 22:41:05 -0700625 kfree(full_path);
Jeff Layton7ffec372010-09-29 19:51:11 -0400626 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 FreeXid(xid);
628 return ERR_PTR(rc);
629}
630
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631static int
632cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
633{
Nick Piggin34286d62011-01-07 17:49:57 +1100634 if (nd->flags & LOOKUP_RCU)
635 return -ECHILD;
636
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 if (direntry->d_inode) {
Jeff Laytondf2cf172010-02-12 07:44:16 -0500638 if (cifs_revalidate_dentry(direntry))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 return 0;
Nick Piggin262f86a2010-11-11 18:42:16 +1100640 else
641 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 }
643
Nick Piggin262f86a2010-11-11 18:42:16 +1100644 /*
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.
647 */
648 if (!nd)
649 return 0;
650
651 /*
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
654 * for creation.
655 */
656 if (!(nd->flags & (LOOKUP_CONTINUE | LOOKUP_PARENT))) {
657 if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
658 return 0;
659 }
660
661 if (time_after(jiffies, direntry->d_time + HZ) || !lookupCacheEnabled)
662 return 0;
663
664 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665}
666
667/* static int cifs_d_delete(struct dentry *direntry)
668{
669 int rc = 0;
670
Joe Perchesb6b38f72010-04-21 03:50:45 +0000671 cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672
673 return rc;
674} */
675
Al Viro4fd03e82009-02-20 05:57:07 +0000676const struct dentry_operations cifs_dentry_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 .d_revalidate = cifs_d_revalidate,
David Howells01c64fe2011-01-14 18:45:47 +0000678 .d_automount = cifs_dfs_d_automount,
Steve French5fdae1f2007-06-05 18:30:44 +0000679/* d_delete: cifs_d_delete, */ /* not needed except for debugging */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680};
Steve Frenchb92327f2005-08-22 20:09:43 -0700681
Nick Pigginb1e6a012011-01-07 17:49:28 +1100682static int cifs_ci_hash(const struct dentry *dentry, const struct inode *inode,
683 struct qstr *q)
Steve Frenchb92327f2005-08-22 20:09:43 -0700684{
Nick Pigginb1e6a012011-01-07 17:49:28 +1100685 struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
Steve Frenchb92327f2005-08-22 20:09:43 -0700686 unsigned long hash;
687 int i;
688
689 hash = init_name_hash();
690 for (i = 0; i < q->len; i++)
691 hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
692 hash);
693 q->hash = end_name_hash(hash);
694
695 return 0;
696}
697
Nick Piggin621e1552011-01-07 17:49:27 +1100698static int cifs_ci_compare(const struct dentry *parent,
699 const struct inode *pinode,
700 const struct dentry *dentry, const struct inode *inode,
701 unsigned int len, const char *str, const struct qstr *name)
Steve Frenchb92327f2005-08-22 20:09:43 -0700702{
Nick Piggin621e1552011-01-07 17:49:27 +1100703 struct nls_table *codepage = CIFS_SB(pinode->i_sb)->local_nls;
Steve Frenchb92327f2005-08-22 20:09:43 -0700704
Nick Piggin621e1552011-01-07 17:49:27 +1100705 if ((name->len == len) &&
706 (nls_strnicmp(codepage, name->name, str, len) == 0))
Steve Frenchb92327f2005-08-22 20:09:43 -0700707 return 0;
Steve Frenchb92327f2005-08-22 20:09:43 -0700708 return 1;
709}
710
Al Viro4fd03e82009-02-20 05:57:07 +0000711const struct dentry_operations cifs_ci_dentry_ops = {
Steve Frenchb92327f2005-08-22 20:09:43 -0700712 .d_revalidate = cifs_d_revalidate,
713 .d_hash = cifs_ci_hash,
714 .d_compare = cifs_ci_compare,
David Howells01c64fe2011-01-14 18:45:47 +0000715 .d_automount = cifs_dfs_d_automount,
Steve Frenchb92327f2005-08-22 20:09:43 -0700716};