blob: fb69c1fa85c975d17b16122fdfbf74a9e835e949 [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 Frenchad7a2922008-02-07 23:25:02 +00006 * Copyright (C) International Business Machines Corp., 2002,2008
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>
27#include "cifsfs.h"
28#include "cifspdu.h"
29#include "cifsglob.h"
30#include "cifsproto.h"
31#include "cifs_debug.h"
32#include "cifs_fs_sb.h"
33
Steve French99ee4db2007-02-27 05:35:17 +000034static void
Linus Torvalds1da177e2005-04-16 15:20:36 -070035renew_parental_timestamps(struct dentry *direntry)
36{
Steve French5fdae1f2007-06-05 18:30:44 +000037 /* BB check if there is a way to get the kernel to do this or if we
38 really need this */
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 do {
40 direntry->d_time = jiffies;
41 direntry = direntry->d_parent;
Steve French5fdae1f2007-06-05 18:30:44 +000042 } while (!IS_ROOT(direntry));
Linus Torvalds1da177e2005-04-16 15:20:36 -070043}
44
45/* Note: caller must free return buffer */
46char *
47build_path_from_dentry(struct dentry *direntry)
48{
49 struct dentry *temp;
Steve French2fe87f02006-09-21 07:02:52 +000050 int namelen;
51 int pplen;
Steve French646dd532008-05-15 01:50:56 +000052 int dfsplen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 char *full_path;
Steve French88274812006-03-09 22:21:45 +000054 char dirsep;
Steve French646dd532008-05-15 01:50:56 +000055 struct cifs_sb_info *cifs_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Steve French5fdae1f2007-06-05 18:30:44 +000057 if (direntry == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 return NULL; /* not much we can do if dentry is freed and
59 we need to reopen the file after it was closed implicitly
60 when the server crashed */
61
Steve French646dd532008-05-15 01:50:56 +000062 cifs_sb = CIFS_SB(direntry->d_sb);
63 dirsep = CIFS_DIR_SEP(cifs_sb);
64 pplen = cifs_sb->prepathlen;
65 if (cifs_sb->tcon && (cifs_sb->tcon->Flags & SMB_SHARE_IS_IN_DFS))
66 dfsplen = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE + 1);
67 else
68 dfsplen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070069cifs_bp_rename_retry:
Steve French646dd532008-05-15 01:50:56 +000070 namelen = pplen + dfsplen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 for (temp = direntry; !IS_ROOT(temp);) {
72 namelen += (1 + temp->d_name.len);
73 temp = temp->d_parent;
Steve French5fdae1f2007-06-05 18:30:44 +000074 if (temp == NULL) {
75 cERROR(1, ("corrupt dentry"));
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 return NULL;
77 }
78 }
79
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 for (temp = direntry; !IS_ROOT(temp);) {
85 namelen -= 1 + temp->d_name.len;
86 if (namelen < 0) {
87 break;
88 } else {
Steve French7f573562005-08-30 11:32:14 -070089 full_path[namelen] = dirsep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 strncpy(full_path + namelen + 1, temp->d_name.name,
91 temp->d_name.len);
Steve French2fe87f02006-09-21 07:02:52 +000092 cFYI(0, ("name: %s", full_path + namelen));
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 }
94 temp = temp->d_parent;
Steve French5fdae1f2007-06-05 18:30:44 +000095 if (temp == NULL) {
96 cERROR(1, ("corrupt dentry"));
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 kfree(full_path);
98 return NULL;
99 }
100 }
Steve French646dd532008-05-15 01:50:56 +0000101 if (namelen != pplen + dfsplen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 cERROR(1,
Steve French2fe87f02006-09-21 07:02:52 +0000103 ("did not end path lookup where expected namelen is %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 namelen));
Steve French5fdae1f2007-06-05 18:30:44 +0000105 /* presumably this is only possible if racing with a rename
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 of one of the parent directories (we can not lock the dentries
107 above us to prevent this, but retrying should be harmless) */
108 kfree(full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 goto cifs_bp_rename_retry;
110 }
Steve French2fe87f02006-09-21 07:02:52 +0000111 /* DIR_SEP already set for byte 0 / vs \ but not for
112 subsequent slashes in prepath which currently must
113 be entered the right way - not sure if there is an alternative
114 since the '\' is a valid posix character so we can not switch
115 those safely to '/' if any are found in the middle of the prepath */
116 /* BB test paths to Windows with '/' in the midst of prepath */
Steve French646dd532008-05-15 01:50:56 +0000117
118 if (dfsplen) {
119 strncpy(full_path, cifs_sb->tcon->treeName, dfsplen);
120 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
121 int i;
122 for (i = 0; i < dfsplen; i++) {
123 if (full_path[i] == '\\')
124 full_path[i] = '/';
125 }
126 }
127 }
128 strncpy(full_path + dfsplen, CIFS_SB(direntry->d_sb)->prepath, pplen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 return full_path;
130}
131
Steve French39798772006-05-31 22:40:51 +0000132/* Inode operations in similar order to how they appear in Linux file fs.h */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
134int
135cifs_create(struct inode *inode, struct dentry *direntry, int mode,
136 struct nameidata *nd)
137{
138 int rc = -ENOENT;
139 int xid;
Jeff Layton67750fb2008-05-09 22:28:02 +0000140 int create_options = CREATE_NOT_DIR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 int oplock = 0;
142 int desiredAccess = GENERIC_READ | GENERIC_WRITE;
143 __u16 fileHandle;
144 struct cifs_sb_info *cifs_sb;
145 struct cifsTconInfo *pTcon;
146 char *full_path = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000147 FILE_ALL_INFO *buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 struct inode *newinode = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000149 struct cifsFileInfo *pCifsFile = NULL;
150 struct cifsInodeInfo *pCifsInode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 int disposition = FILE_OVERWRITE_IF;
Steve French4b18f2a2008-04-29 00:06:05 +0000152 bool write_only = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 xid = GetXid();
155
156 cifs_sb = CIFS_SB(inode->i_sb);
157 pTcon = cifs_sb->tcon;
158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 full_path = build_path_from_dentry(direntry);
Steve French5fdae1f2007-06-05 18:30:44 +0000160 if (full_path == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 FreeXid(xid);
162 return -ENOMEM;
163 }
164
Steve French5fdae1f2007-06-05 18:30:44 +0000165 if (nd && (nd->flags & LOOKUP_OPEN)) {
Miklos Szeredie08fc042005-09-06 15:18:26 -0700166 int oflags = nd->intent.open.flags;
167
168 desiredAccess = 0;
169 if (oflags & FMODE_READ)
170 desiredAccess |= GENERIC_READ;
171 if (oflags & FMODE_WRITE) {
172 desiredAccess |= GENERIC_WRITE;
173 if (!(oflags & FMODE_READ))
Steve French4b18f2a2008-04-29 00:06:05 +0000174 write_only = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 }
176
Steve French5fdae1f2007-06-05 18:30:44 +0000177 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 disposition = FILE_CREATE;
Steve French5fdae1f2007-06-05 18:30:44 +0000179 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 disposition = FILE_OVERWRITE_IF;
Steve French5fdae1f2007-06-05 18:30:44 +0000181 else if ((oflags & O_CREAT) == O_CREAT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 disposition = FILE_OPEN_IF;
Steve Frenchad7a2922008-02-07 23:25:02 +0000183 else
Steve French5fdae1f2007-06-05 18:30:44 +0000184 cFYI(1, ("Create flag not set in create function"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 }
186
Steve French5fdae1f2007-06-05 18:30:44 +0000187 /* BB add processing to set equivalent of mode - e.g. via CreateX with
188 ACLs */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 if (oplockEnabled)
190 oplock = REQ_OPLOCK;
191
Steve French5fdae1f2007-06-05 18:30:44 +0000192 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
193 if (buf == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 kfree(full_path);
195 FreeXid(xid);
196 return -ENOMEM;
197 }
Jeff Layton67750fb2008-05-09 22:28:02 +0000198
199 mode &= ~current->fs->umask;
200
201 /*
202 * if we're not using unix extensions, see if we need to set
203 * ATTR_READONLY on the create call
204 */
205 if (!pTcon->unix_ext && (mode & S_IWUGO) == 0)
206 create_options |= CREATE_OPTION_READONLY;
207
Steve French5fdae1f2007-06-05 18:30:44 +0000208 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
Steve French5bafd762006-06-07 00:18:43 +0000209 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition,
Jeff Layton67750fb2008-05-09 22:28:02 +0000210 desiredAccess, create_options,
Steve French737b7582005-04-28 22:41:06 -0700211 &fileHandle, &oplock, buf, cifs_sb->local_nls,
212 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000213 else
214 rc = -EIO; /* no NT SMB support fall into legacy open below */
215
Steve French5fdae1f2007-06-05 18:30:44 +0000216 if (rc == -EIO) {
Steve Frencha9d02ad2005-08-24 23:06:05 -0700217 /* old server, retry the open legacy style */
218 rc = SMBLegacyOpen(xid, pTcon, full_path, disposition,
Jeff Layton67750fb2008-05-09 22:28:02 +0000219 desiredAccess, create_options,
Steve Frencha9d02ad2005-08-24 23:06:05 -0700220 &fileHandle, &oplock, buf, cifs_sb->local_nls,
221 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5fdae1f2007-06-05 18:30:44 +0000222 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 if (rc) {
Steve French26a21b92006-05-31 18:05:34 +0000224 cFYI(1, ("cifs_create returned 0x%x", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 } else {
226 /* If Open reported that we actually created a file
227 then we now have to set the mode if possible */
Steve Frenchc18c8422007-07-18 23:21:09 +0000228 if ((pTcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
Steve French5fdae1f2007-06-05 18:30:44 +0000229 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode,
Steve French83451872005-12-01 17:12:59 -0800231 (__u64)current->fsuid,
232 (__u64)current->fsgid,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 0 /* dev */,
Steve French5fdae1f2007-06-05 18:30:44 +0000234 cifs_sb->local_nls,
235 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700236 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 } else {
238 CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode,
239 (__u64)-1,
240 (__u64)-1,
241 0 /* dev */,
Steve French737b7582005-04-28 22:41:06 -0700242 cifs_sb->local_nls,
Steve French5fdae1f2007-06-05 18:30:44 +0000243 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700244 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 }
Steve French3ce53fc2007-06-08 14:55:14 +0000246 } else {
Steve French5fdae1f2007-06-05 18:30:44 +0000247 /* BB implement mode setting via Windows security
248 descriptors e.g. */
249 /* CIFSSMBWinSetPerms(xid,pTcon,path,mode,-1,-1,nls);*/
250
251 /* Could set r/o dos attribute if mode & 0222 == 0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 }
253
Steve Frenchc18c8422007-07-18 23:21:09 +0000254 /* server might mask mode so we have to query for it */
255 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve French5fdae1f2007-06-05 18:30:44 +0000257 inode->i_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 else {
259 rc = cifs_get_inode_info(&newinode, full_path,
Steve French8b1327f2008-03-14 22:37:16 +0000260 buf, inode->i_sb, xid,
261 &fileHandle);
Steve French5fdae1f2007-06-05 18:30:44 +0000262 if (newinode) {
Jeff Laytonb0fd30d2008-05-22 09:33:34 -0400263 if (cifs_sb->mnt_cifs_flags &
264 CIFS_MOUNT_DYNPERM)
265 newinode->i_mode = mode;
Steve French5fdae1f2007-06-05 18:30:44 +0000266 if ((oplock & CIFS_CREATE_ACTION) &&
267 (cifs_sb->mnt_cifs_flags &
Steve French6473a552005-11-29 20:20:10 -0800268 CIFS_MOUNT_SET_UID)) {
269 newinode->i_uid = current->fsuid;
270 newinode->i_gid = current->fsgid;
271 }
272 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 }
274
275 if (rc != 0) {
Steve French4a6d87f2005-08-13 08:15:54 -0700276 cFYI(1,
277 ("Create worked but get_inode_info failed rc = %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 rc));
279 } else {
Steve Frenchb92327f2005-08-22 20:09:43 -0700280 if (pTcon->nocase)
281 direntry->d_op = &cifs_ci_dentry_ops;
282 else
283 direntry->d_op = &cifs_dentry_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 d_instantiate(direntry, newinode);
285 }
Steve French7521a3c2007-07-11 18:30:34 +0000286 if ((nd == NULL /* nfsd case - nfs srv does not set nd */) ||
Steve French4b18f2a2008-04-29 00:06:05 +0000287 (!(nd->flags & LOOKUP_OPEN))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 /* mknod case - do not leave file open */
289 CIFSSMBClose(xid, pTcon, fileHandle);
Steve French5fdae1f2007-06-05 18:30:44 +0000290 } else if (newinode) {
Steve Frenchd14537f12005-04-28 22:41:05 -0700291 pCifsFile =
Steve French92ad9b92007-09-29 05:21:58 +0000292 kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
Steve French221601c2007-06-05 20:35:06 +0000293
Steve French5fdae1f2007-06-05 18:30:44 +0000294 if (pCifsFile == NULL)
Steve Frenchd14537f12005-04-28 22:41:05 -0700295 goto cifs_create_out;
Steve Frenchd14537f12005-04-28 22:41:05 -0700296 pCifsFile->netfid = fileHandle;
297 pCifsFile->pid = current->tgid;
298 pCifsFile->pInode = newinode;
Steve French4b18f2a2008-04-29 00:06:05 +0000299 pCifsFile->invalidHandle = false;
300 pCifsFile->closePend = false;
Steve Frenchd14537f12005-04-28 22:41:05 -0700301 init_MUTEX(&pCifsFile->fh_sem);
Roland Dreier796e5662007-05-03 04:33:45 +0000302 mutex_init(&pCifsFile->lock_mutex);
Steve Frenche466e482006-08-15 13:07:18 +0000303 INIT_LIST_HEAD(&pCifsFile->llist);
Steve French5fdae1f2007-06-05 18:30:44 +0000304 atomic_set(&pCifsFile->wrtPending, 0);
Steve Frenche466e482006-08-15 13:07:18 +0000305
Steve French5fdae1f2007-06-05 18:30:44 +0000306 /* set the following in open now
Steve Frenchd14537f12005-04-28 22:41:05 -0700307 pCifsFile->pfile = file; */
308 write_lock(&GlobalSMBSeslock);
Steve French5fdae1f2007-06-05 18:30:44 +0000309 list_add(&pCifsFile->tlist, &pTcon->openFileList);
Steve Frenchd14537f12005-04-28 22:41:05 -0700310 pCifsInode = CIFS_I(newinode);
Steve French5fdae1f2007-06-05 18:30:44 +0000311 if (pCifsInode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 /* if readable file instance put first in list*/
Steve French4b18f2a2008-04-29 00:06:05 +0000313 if (write_only) {
Steve French5fdae1f2007-06-05 18:30:44 +0000314 list_add_tail(&pCifsFile->flist,
Steve Frenchd14537f12005-04-28 22:41:05 -0700315 &pCifsInode->openFileList);
316 } else {
317 list_add(&pCifsFile->flist,
318 &pCifsInode->openFileList);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 }
Steve French5fdae1f2007-06-05 18:30:44 +0000320 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000321 pCifsInode->clientCanCacheAll = true;
322 pCifsInode->clientCanCacheRead = true;
Steve French221601c2007-06-05 20:35:06 +0000323 cFYI(1, ("Exclusive Oplock inode %p",
Steve Frenchd14537f12005-04-28 22:41:05 -0700324 newinode));
Steve French5fdae1f2007-06-05 18:30:44 +0000325 } else if ((oplock & 0xF) == OPLOCK_READ)
Steve French4b18f2a2008-04-29 00:06:05 +0000326 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 }
Steve Frenchd14537f12005-04-28 22:41:05 -0700328 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 }
Steve French5fdae1f2007-06-05 18:30:44 +0000330 }
Steve Frenchd14537f12005-04-28 22:41:05 -0700331cifs_create_out:
332 kfree(buf);
333 kfree(full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 FreeXid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 return rc;
336}
337
Steve French5fdae1f2007-06-05 18:30:44 +0000338int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
339 dev_t device_number)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340{
341 int rc = -EPERM;
342 int xid;
343 struct cifs_sb_info *cifs_sb;
344 struct cifsTconInfo *pTcon;
345 char *full_path = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000346 struct inode *newinode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
348 if (!old_valid_dev(device_number))
349 return -EINVAL;
350
351 xid = GetXid();
352
353 cifs_sb = CIFS_SB(inode->i_sb);
354 pTcon = cifs_sb->tcon;
355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 full_path = build_path_from_dentry(direntry);
Steve French5fdae1f2007-06-05 18:30:44 +0000357 if (full_path == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 rc = -ENOMEM;
Steve Frenchc18c8422007-07-18 23:21:09 +0000359 else if (pTcon->unix_ext) {
Steve French3ce53fc2007-06-08 14:55:14 +0000360 mode &= ~current->fs->umask;
Steve French5fdae1f2007-06-05 18:30:44 +0000361 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 rc = CIFSSMBUnixSetPerms(xid, pTcon, full_path,
Steve French5fdae1f2007-06-05 18:30:44 +0000363 mode, (__u64)current->fsuid,
364 (__u64)current->fsgid,
Steve French737b7582005-04-28 22:41:06 -0700365 device_number, cifs_sb->local_nls,
Steve French5fdae1f2007-06-05 18:30:44 +0000366 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700367 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 } else {
369 rc = CIFSSMBUnixSetPerms(xid, pTcon,
370 full_path, mode, (__u64)-1, (__u64)-1,
Steve French737b7582005-04-28 22:41:06 -0700371 device_number, cifs_sb->local_nls,
Steve French5fdae1f2007-06-05 18:30:44 +0000372 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700373 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 }
375
Steve French5fdae1f2007-06-05 18:30:44 +0000376 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve French5fdae1f2007-06-05 18:30:44 +0000378 inode->i_sb, xid);
Steve Frenchb92327f2005-08-22 20:09:43 -0700379 if (pTcon->nocase)
380 direntry->d_op = &cifs_ci_dentry_ops;
381 else
382 direntry->d_op = &cifs_dentry_ops;
Steve French5fdae1f2007-06-05 18:30:44 +0000383 if (rc == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 d_instantiate(direntry, newinode);
385 }
Steve Frenchd7245c22005-07-14 18:25:12 -0500386 } else {
Steve French5fdae1f2007-06-05 18:30:44 +0000387 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
Steve Frencheda3c022005-07-21 15:20:28 -0700388 int oplock = 0;
389 u16 fileHandle;
Steve Frenchad7a2922008-02-07 23:25:02 +0000390 FILE_ALL_INFO *buf;
Steve Frenchd7245c22005-07-14 18:25:12 -0500391
Steve French5fdae1f2007-06-05 18:30:44 +0000392 cFYI(1, ("sfu compat create special file"));
Steve Frenchd7245c22005-07-14 18:25:12 -0500393
Steve French5fdae1f2007-06-05 18:30:44 +0000394 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
395 if (buf == NULL) {
Steve Frencheda3c022005-07-21 15:20:28 -0700396 kfree(full_path);
397 FreeXid(xid);
398 return -ENOMEM;
399 }
400
401 rc = CIFSSMBOpen(xid, pTcon, full_path,
402 FILE_CREATE, /* fail if exists */
Steve French5fdae1f2007-06-05 18:30:44 +0000403 GENERIC_WRITE /* BB would
Steve Frencheda3c022005-07-21 15:20:28 -0700404 WRITE_OWNER | WRITE_DAC be better? */,
405 /* Create a file and set the
406 file attribute to SYSTEM */
407 CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,
408 &fileHandle, &oplock, buf,
409 cifs_sb->local_nls,
Steve French5fdae1f2007-06-05 18:30:44 +0000410 cifs_sb->mnt_cifs_flags &
Steve Frencheda3c022005-07-21 15:20:28 -0700411 CIFS_MOUNT_MAP_SPECIAL_CHR);
412
Steve French5bafd762006-06-07 00:18:43 +0000413 /* BB FIXME - add handling for backlevel servers
414 which need legacy open and check for all
Steve French5fdae1f2007-06-05 18:30:44 +0000415 calls to SMBOpen for fallback to SMBLeagcyOpen */
416 if (!rc) {
Steve Frencheda3c022005-07-21 15:20:28 -0700417 /* BB Do not bother to decode buf since no
Steve French86c96b42005-11-18 20:25:31 -0800418 local inode yet to put timestamps in,
419 but we can reuse it safely */
Steve French77159b42007-08-31 01:10:17 +0000420 unsigned int bytes_written;
Steve French86c96b42005-11-18 20:25:31 -0800421 struct win_dev *pdev;
422 pdev = (struct win_dev *)buf;
Steve French5fdae1f2007-06-05 18:30:44 +0000423 if (S_ISCHR(mode)) {
Steve French86c96b42005-11-18 20:25:31 -0800424 memcpy(pdev->type, "IntxCHR", 8);
425 pdev->major =
426 cpu_to_le64(MAJOR(device_number));
Steve French5fdae1f2007-06-05 18:30:44 +0000427 pdev->minor =
Steve French86c96b42005-11-18 20:25:31 -0800428 cpu_to_le64(MINOR(device_number));
429 rc = CIFSSMBWrite(xid, pTcon,
430 fileHandle,
431 sizeof(struct win_dev),
432 0, &bytes_written, (char *)pdev,
433 NULL, 0);
Steve French5fdae1f2007-06-05 18:30:44 +0000434 } else if (S_ISBLK(mode)) {
Steve French86c96b42005-11-18 20:25:31 -0800435 memcpy(pdev->type, "IntxBLK", 8);
436 pdev->major =
437 cpu_to_le64(MAJOR(device_number));
438 pdev->minor =
439 cpu_to_le64(MINOR(device_number));
440 rc = CIFSSMBWrite(xid, pTcon,
441 fileHandle,
442 sizeof(struct win_dev),
443 0, &bytes_written, (char *)pdev,
444 NULL, 0);
445 } /* else if(S_ISFIFO */
Steve Frencheda3c022005-07-21 15:20:28 -0700446 CIFSSMBClose(xid, pTcon, fileHandle);
447 d_drop(direntry);
448 }
449 kfree(buf);
Steve Frenchd7245c22005-07-14 18:25:12 -0500450 /* add code here to set EAs */
451 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 }
453
Steve Frenchd14537f12005-04-28 22:41:05 -0700454 kfree(full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 FreeXid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 return rc;
457}
458
459
460struct dentry *
Steve French5fdae1f2007-06-05 18:30:44 +0000461cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
462 struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463{
464 int xid;
465 int rc = 0; /* to get around spurious gcc warning, set to zero here */
466 struct cifs_sb_info *cifs_sb;
467 struct cifsTconInfo *pTcon;
468 struct inode *newInode = NULL;
469 char *full_path = NULL;
470
471 xid = GetXid();
472
Steve French92ad9b92007-09-29 05:21:58 +0000473 cFYI(1, (" parent inode = 0x%p name is: %s and dentry = 0x%p",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 parent_dir_inode, direntry->d_name.name, direntry));
475
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 /* check whether path exists */
477
478 cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
479 pTcon = cifs_sb->tcon;
480
Steve French296034f2006-04-21 18:18:37 +0000481 /*
482 * Don't allow the separator character in a path component.
483 * The VFS will not allow "/", but "\" is allowed by posix.
484 */
485 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
486 int i;
487 for (i = 0; i < direntry->d_name.len; i++)
488 if (direntry->d_name.name[i] == '\\') {
489 cFYI(1, ("Invalid file name"));
490 FreeXid(xid);
491 return ERR_PTR(-EINVAL);
492 }
493 }
494
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 /* can not grab the rename sem here since it would
496 deadlock in the cases (beginning of sys_rename itself)
497 in which we already have the sb rename sem */
498 full_path = build_path_from_dentry(direntry);
Steve French5fdae1f2007-06-05 18:30:44 +0000499 if (full_path == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 FreeXid(xid);
501 return ERR_PTR(-ENOMEM);
502 }
503
504 if (direntry->d_inode != NULL) {
505 cFYI(1, (" non-NULL inode in lookup"));
506 } else {
507 cFYI(1, (" NULL inode in lookup"));
508 }
509 cFYI(1,
510 (" Full path: %s inode = 0x%p", full_path, direntry->d_inode));
511
Steve Frenchc18c8422007-07-18 23:21:09 +0000512 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 rc = cifs_get_inode_info_unix(&newInode, full_path,
Steve French5fdae1f2007-06-05 18:30:44 +0000514 parent_dir_inode->i_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 else
516 rc = cifs_get_inode_info(&newInode, full_path, NULL,
Steve French8b1327f2008-03-14 22:37:16 +0000517 parent_dir_inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
519 if ((rc == 0) && (newInode != NULL)) {
Steve Frenchb92327f2005-08-22 20:09:43 -0700520 if (pTcon->nocase)
521 direntry->d_op = &cifs_ci_dentry_ops;
522 else
523 direntry->d_op = &cifs_dentry_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 d_add(direntry, newInode);
525
Steve French5fdae1f2007-06-05 18:30:44 +0000526 /* since paths are not looked up by component - the parent
Steve French3abb9272005-11-28 08:16:13 -0800527 directories are presumed to be good here */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 renew_parental_timestamps(direntry);
529
530 } else if (rc == -ENOENT) {
531 rc = 0;
Steve French3abb9272005-11-28 08:16:13 -0800532 direntry->d_time = jiffies;
533 if (pTcon->nocase)
534 direntry->d_op = &cifs_ci_dentry_ops;
535 else
536 direntry->d_op = &cifs_dentry_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 d_add(direntry, NULL);
Steve French5fdae1f2007-06-05 18:30:44 +0000538 /* if it was once a directory (but how can we tell?) we could do
539 shrink_dcache_parent(direntry); */
Steve Frenched2b9172008-01-20 00:30:29 +0000540 } else if (rc != -EACCES) {
541 cERROR(1, ("Unexpected lookup error %d", rc));
542 /* We special case check for Access Denied - since that
543 is a common return code */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 }
545
Steve Frenchd14537f12005-04-28 22:41:05 -0700546 kfree(full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 FreeXid(xid);
548 return ERR_PTR(rc);
549}
550
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551static int
552cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
553{
554 int isValid = 1;
555
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 if (direntry->d_inode) {
Steve Frenchad7a2922008-02-07 23:25:02 +0000557 if (cifs_revalidate(direntry))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 } else {
Steve French3abb9272005-11-28 08:16:13 -0800560 cFYI(1, ("neg dentry 0x%p name = %s",
561 direntry, direntry->d_name.name));
Steve French5fdae1f2007-06-05 18:30:44 +0000562 if (time_after(jiffies, direntry->d_time + HZ) ||
Steve French3abb9272005-11-28 08:16:13 -0800563 !lookupCacheEnabled) {
564 d_drop(direntry);
565 isValid = 0;
Steve French5fdae1f2007-06-05 18:30:44 +0000566 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 }
568
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 return isValid;
570}
571
572/* static int cifs_d_delete(struct dentry *direntry)
573{
574 int rc = 0;
575
576 cFYI(1, ("In cifs d_delete, name = %s", direntry->d_name.name));
577
578 return rc;
579} */
580
581struct dentry_operations cifs_dentry_ops = {
582 .d_revalidate = cifs_d_revalidate,
Steve French5fdae1f2007-06-05 18:30:44 +0000583/* d_delete: cifs_d_delete, */ /* not needed except for debugging */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584};
Steve Frenchb92327f2005-08-22 20:09:43 -0700585
586static int cifs_ci_hash(struct dentry *dentry, struct qstr *q)
587{
588 struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
589 unsigned long hash;
590 int i;
591
592 hash = init_name_hash();
593 for (i = 0; i < q->len; i++)
594 hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
595 hash);
596 q->hash = end_name_hash(hash);
597
598 return 0;
599}
600
601static int cifs_ci_compare(struct dentry *dentry, struct qstr *a,
602 struct qstr *b)
603{
604 struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
605
606 if ((a->len == b->len) &&
607 (nls_strnicmp(codepage, a->name, b->name, a->len) == 0)) {
608 /*
609 * To preserve case, don't let an existing negative dentry's
610 * case take precedence. If a is not a negative dentry, this
611 * should have no side effects
612 */
Steve Frenchc3291632008-05-15 05:41:54 +0000613 memcpy((void *)a->name, b->name, a->len);
Steve Frenchb92327f2005-08-22 20:09:43 -0700614 return 0;
615 }
616 return 1;
617}
618
619struct dentry_operations cifs_ci_dentry_ops = {
620 .d_revalidate = cifs_d_revalidate,
621 .d_hash = cifs_ci_hash,
622 .d_compare = cifs_ci_compare,
623};