blob: 1f42f772865a54f1f45b516b090533a4a4715bf4 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include "cifsfs.h"
29#include "cifspdu.h"
30#include "cifsglob.h"
31#include "cifsproto.h"
32#include "cifs_debug.h"
33#include "cifs_fs_sb.h"
34
Steve French99ee4db2007-02-27 05:35:17 +000035static void
Linus Torvalds1da177e2005-04-16 15:20:36 -070036renew_parental_timestamps(struct dentry *direntry)
37{
Steve French5fdae1f2007-06-05 18:30:44 +000038 /* BB check if there is a way to get the kernel to do this or if we
39 really need this */
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 do {
41 direntry->d_time = jiffies;
42 direntry = direntry->d_parent;
Steve French5fdae1f2007-06-05 18:30:44 +000043 } while (!IS_ROOT(direntry));
Linus Torvalds1da177e2005-04-16 15:20:36 -070044}
45
46/* Note: caller must free return buffer */
47char *
48build_path_from_dentry(struct dentry *direntry)
49{
50 struct dentry *temp;
Steve French2fe87f02006-09-21 07:02:52 +000051 int namelen;
52 int pplen;
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;
Steve French646dd532008-05-15 01:50:56 +000056 struct cifs_sb_info *cifs_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
Steve French5fdae1f2007-06-05 18:30:44 +000058 if (direntry == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 return NULL; /* not much we can do if dentry is freed and
60 we need to reopen the file after it was closed implicitly
61 when the server crashed */
62
Steve French646dd532008-05-15 01:50:56 +000063 cifs_sb = CIFS_SB(direntry->d_sb);
64 dirsep = CIFS_DIR_SEP(cifs_sb);
65 pplen = cifs_sb->prepathlen;
66 if (cifs_sb->tcon && (cifs_sb->tcon->Flags & SMB_SHARE_IS_IN_DFS))
67 dfsplen = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE + 1);
68 else
69 dfsplen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070cifs_bp_rename_retry:
Steve French646dd532008-05-15 01:50:56 +000071 namelen = pplen + dfsplen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 for (temp = direntry; !IS_ROOT(temp);) {
73 namelen += (1 + temp->d_name.len);
74 temp = temp->d_parent;
Steve French5fdae1f2007-06-05 18:30:44 +000075 if (temp == NULL) {
76 cERROR(1, ("corrupt dentry"));
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 return NULL;
78 }
79 }
80
81 full_path = kmalloc(namelen+1, GFP_KERNEL);
Steve French5fdae1f2007-06-05 18:30:44 +000082 if (full_path == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 return full_path;
84 full_path[namelen] = 0; /* trailing null */
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 for (temp = direntry; !IS_ROOT(temp);) {
86 namelen -= 1 + temp->d_name.len;
87 if (namelen < 0) {
88 break;
89 } else {
Steve French7f573562005-08-30 11:32:14 -070090 full_path[namelen] = dirsep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 strncpy(full_path + namelen + 1, temp->d_name.name,
92 temp->d_name.len);
Steve French2fe87f02006-09-21 07:02:52 +000093 cFYI(0, ("name: %s", full_path + namelen));
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 }
95 temp = temp->d_parent;
Steve French5fdae1f2007-06-05 18:30:44 +000096 if (temp == NULL) {
97 cERROR(1, ("corrupt dentry"));
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 kfree(full_path);
99 return NULL;
100 }
101 }
Steve French646dd532008-05-15 01:50:56 +0000102 if (namelen != pplen + dfsplen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 cERROR(1,
Steve French2fe87f02006-09-21 07:02:52 +0000104 ("did not end path lookup where expected namelen is %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 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) {
120 strncpy(full_path, cifs_sb->tcon->treeName, dfsplen);
121 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
Jeff Layton086f68b2009-09-21 14:08:18 -0400133struct cifsFileInfo *
134cifs_new_fileinfo(struct inode *newinode, __u16 fileHandle,
135 struct file *file, struct vfsmount *mnt, unsigned int oflags)
Steve Frencha6ce4932009-04-09 01:14:32 +0000136{
137 int oplock = 0;
138 struct cifsFileInfo *pCifsFile;
139 struct cifsInodeInfo *pCifsInode;
Jeff Layton3bc303c2009-09-21 06:47:50 -0400140 struct cifs_sb_info *cifs_sb = CIFS_SB(mnt->mnt_sb);
Steve Frencha6ce4932009-04-09 01:14:32 +0000141
142 pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
Steve Frencha6ce4932009-04-09 01:14:32 +0000143 if (pCifsFile == NULL)
Jeff Layton086f68b2009-09-21 14:08:18 -0400144 return pCifsFile;
Steve Frencha6ce4932009-04-09 01:14:32 +0000145
146 if (oplockEnabled)
147 oplock = REQ_OPLOCK;
148
149 pCifsFile->netfid = fileHandle;
150 pCifsFile->pid = current->tgid;
Jeff Layton48541bd2009-09-12 11:54:29 -0400151 pCifsFile->pInode = igrab(newinode);
Jeff Layton3bc303c2009-09-21 06:47:50 -0400152 pCifsFile->mnt = mnt;
Jeff Layton086f68b2009-09-21 14:08:18 -0400153 pCifsFile->pfile = file;
Steve Frencha6ce4932009-04-09 01:14:32 +0000154 pCifsFile->invalidHandle = false;
Steve Frenchbc8cd432009-04-12 18:18:40 +0000155 pCifsFile->closePend = false;
Steve Frencha6ce4932009-04-09 01:14:32 +0000156 mutex_init(&pCifsFile->fh_mutex);
157 mutex_init(&pCifsFile->lock_mutex);
158 INIT_LIST_HEAD(&pCifsFile->llist);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -0400159 atomic_set(&pCifsFile->count, 1);
Jeff Layton3bc303c2009-09-21 06:47:50 -0400160 slow_work_init(&pCifsFile->oplock_break, &cifs_oplock_break_ops);
Steve Frencha6ce4932009-04-09 01:14:32 +0000161
Steve Frencha6ce4932009-04-09 01:14:32 +0000162 write_lock(&GlobalSMBSeslock);
Jeff Layton3bc303c2009-09-21 06:47:50 -0400163 list_add(&pCifsFile->tlist, &cifs_sb->tcon->openFileList);
Steve Frencha6ce4932009-04-09 01:14:32 +0000164 pCifsInode = CIFS_I(newinode);
165 if (pCifsInode) {
166 /* if readable file instance put first in list*/
Jeff Layton086f68b2009-09-21 14:08:18 -0400167 if (oflags & FMODE_READ)
168 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
169 else
Steve Frencha6ce4932009-04-09 01:14:32 +0000170 list_add_tail(&pCifsFile->flist,
171 &pCifsInode->openFileList);
Steve Frenchbc8cd432009-04-12 18:18:40 +0000172
Steve Frencha6ce4932009-04-09 01:14:32 +0000173 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
174 pCifsInode->clientCanCacheAll = true;
175 pCifsInode->clientCanCacheRead = true;
Steve Frenchbc8cd432009-04-12 18:18:40 +0000176 cFYI(1, ("Exclusive Oplock inode %p", newinode));
Steve Frencha6ce4932009-04-09 01:14:32 +0000177 } else if ((oplock & 0xF) == OPLOCK_READ)
Steve Frenchbc8cd432009-04-12 18:18:40 +0000178 pCifsInode->clientCanCacheRead = true;
Steve Frencha6ce4932009-04-09 01:14:32 +0000179 }
180 write_unlock(&GlobalSMBSeslock);
Jeff Layton086f68b2009-09-21 14:08:18 -0400181
182 return pCifsFile;
Steve Frencha6ce4932009-04-09 01:14:32 +0000183}
184
Steve French7fc8f4e2009-02-23 20:43:11 +0000185int cifs_posix_open(char *full_path, struct inode **pinode,
Jeff Layton3bc303c2009-09-21 06:47:50 -0400186 struct vfsmount *mnt, int mode, int oflags,
Jeff Layton590a3fe2009-09-12 11:54:28 -0400187 __u32 *poplock, __u16 *pnetfid, int xid)
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000188{
189 int rc;
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000190 FILE_UNIX_BASIC_INFO *presp_data;
191 __u32 posix_flags = 0;
Jeff Layton3bc303c2009-09-21 06:47:50 -0400192 struct cifs_sb_info *cifs_sb = CIFS_SB(mnt->mnt_sb);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400193 struct cifs_fattr fattr;
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000194
195 cFYI(1, ("posix open %s", full_path));
196
197 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
198 if (presp_data == NULL)
199 return -ENOMEM;
200
201/* So far cifs posix extensions can only map the following flags.
202 There are other valid fmode oflags such as FMODE_LSEEK, FMODE_PREAD, but
203 so far we do not seem to need them, and we can treat them as local only */
204 if ((oflags & (FMODE_READ | FMODE_WRITE)) ==
205 (FMODE_READ | FMODE_WRITE))
206 posix_flags = SMB_O_RDWR;
207 else if (oflags & FMODE_READ)
208 posix_flags = SMB_O_RDONLY;
209 else if (oflags & FMODE_WRITE)
210 posix_flags = SMB_O_WRONLY;
211 if (oflags & O_CREAT)
212 posix_flags |= SMB_O_CREAT;
213 if (oflags & O_EXCL)
214 posix_flags |= SMB_O_EXCL;
215 if (oflags & O_TRUNC)
216 posix_flags |= SMB_O_TRUNC;
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000217 if (oflags & O_SYNC)
218 posix_flags |= SMB_O_SYNC;
219 if (oflags & O_DIRECTORY)
220 posix_flags |= SMB_O_DIRECTORY;
221 if (oflags & O_NOFOLLOW)
222 posix_flags |= SMB_O_NOFOLLOW;
223 if (oflags & O_DIRECT)
224 posix_flags |= SMB_O_DIRECT;
225
Steve French703a3b82009-05-21 22:21:53 +0000226 mode &= ~current_umask();
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000227 rc = CIFSPOSIXCreate(xid, cifs_sb->tcon, posix_flags, mode,
Jeff Layton590a3fe2009-09-12 11:54:28 -0400228 pnetfid, presp_data, poplock, full_path,
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000229 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
230 CIFS_MOUNT_MAP_SPECIAL_CHR);
231 if (rc)
232 goto posix_open_ret;
233
234 if (presp_data->Type == cpu_to_le32(-1))
235 goto posix_open_ret; /* open ok, caller does qpathinfo */
236
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000237 if (!pinode)
238 goto posix_open_ret; /* caller does not need info */
239
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400240 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
241
242 /* get new inode and set it up */
Steve French85a6dac2009-04-01 05:22:00 +0000243 if (*pinode == NULL) {
Jeff Layton3bc303c2009-09-21 06:47:50 -0400244 *pinode = cifs_iget(mnt->mnt_sb, &fattr);
Jeff Laytoncc0bad72009-06-25 00:56:52 -0400245 if (!*pinode) {
246 rc = -ENOMEM;
247 goto posix_open_ret;
248 }
249 } else {
250 cifs_fattr_to_inode(*pinode, &fattr);
Steve French85a6dac2009-04-01 05:22:00 +0000251 }
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000252
Jeff Layton086f68b2009-09-21 14:08:18 -0400253 cifs_new_fileinfo(*pinode, *pnetfid, NULL, mnt, oflags);
Steve Frencha6ce4932009-04-09 01:14:32 +0000254
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000255posix_open_ret:
256 kfree(presp_data);
257 return rc;
258}
259
Steve Frenchf818dd52009-01-19 02:38:35 +0000260static void setup_cifs_dentry(struct cifsTconInfo *tcon,
261 struct dentry *direntry,
262 struct inode *newinode)
263{
264 if (tcon->nocase)
265 direntry->d_op = &cifs_ci_dentry_ops;
266 else
267 direntry->d_op = &cifs_dentry_ops;
268 d_instantiate(direntry, newinode);
269}
270
Steve French39798772006-05-31 22:40:51 +0000271/* Inode operations in similar order to how they appear in Linux file fs.h */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
273int
274cifs_create(struct inode *inode, struct dentry *direntry, int mode,
275 struct nameidata *nd)
276{
277 int rc = -ENOENT;
278 int xid;
Jeff Layton67750fb2008-05-09 22:28:02 +0000279 int create_options = CREATE_NOT_DIR;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400280 __u32 oplock = 0;
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000281 int oflags;
Steve French90e4ee52009-05-08 03:04:30 +0000282 bool posix_create = false;
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000283 /*
284 * BB below access is probably too much for mknod to request
285 * but we have to do query and setpathinfo so requesting
286 * less could fail (unless we want to request getatr and setatr
287 * permissions (only). At least for POSIX we do not have to
288 * request so much.
289 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 int desiredAccess = GENERIC_READ | GENERIC_WRITE;
291 __u16 fileHandle;
292 struct cifs_sb_info *cifs_sb;
Steve Frenchf818dd52009-01-19 02:38:35 +0000293 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 char *full_path = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000295 FILE_ALL_INFO *buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 struct inode *newinode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 int disposition = FILE_OVERWRITE_IF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
299 xid = GetXid();
300
301 cifs_sb = CIFS_SB(inode->i_sb);
Steve Frenchf818dd52009-01-19 02:38:35 +0000302 tcon = cifs_sb->tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 full_path = build_path_from_dentry(direntry);
Steve French5fdae1f2007-06-05 18:30:44 +0000305 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530306 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530308 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 }
310
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000311 if (oplockEnabled)
312 oplock = REQ_OPLOCK;
313
314 if (nd && (nd->flags & LOOKUP_OPEN))
315 oflags = nd->intent.open.flags;
316 else
317 oflags = FMODE_READ;
318
319 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
320 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
321 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton3bc303c2009-09-21 06:47:50 -0400322 rc = cifs_posix_open(full_path, &newinode, nd->path.mnt,
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000323 mode, oflags, &oplock, &fileHandle, xid);
324 /* EIO could indicate that (posix open) operation is not
325 supported, despite what server claimed in capability
326 negotation. EREMOTE indicates DFS junction, which is not
327 handled in posix open */
328
Steve French90e4ee52009-05-08 03:04:30 +0000329 if (rc == 0) {
330 posix_create = true;
331 if (newinode == NULL) /* query inode info */
332 goto cifs_create_get_file_info;
333 else /* success, no need to query */
334 goto cifs_create_set_dentry;
335 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
Steve French703a3b82009-05-21 22:21:53 +0000336 (rc != -EOPNOTSUPP) && (rc != -EINVAL))
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000337 goto cifs_create_out;
338 /* else fallthrough to retry, using older open call, this is
339 case where server does not support this SMB level, and
340 falsely claims capability (also get here for DFS case
341 which should be rare for path not covered on files) */
342 }
Steve Frenchf818dd52009-01-19 02:38:35 +0000343
Steve French5fdae1f2007-06-05 18:30:44 +0000344 if (nd && (nd->flags & LOOKUP_OPEN)) {
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000345 /* if the file is going to stay open, then we
346 need to set the desired access properly */
Miklos Szeredie08fc042005-09-06 15:18:26 -0700347 desiredAccess = 0;
348 if (oflags & FMODE_READ)
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000349 desiredAccess |= GENERIC_READ; /* is this too little? */
Jeff Layton086f68b2009-09-21 14:08:18 -0400350 if (oflags & FMODE_WRITE)
Miklos Szeredie08fc042005-09-06 15:18:26 -0700351 desiredAccess |= GENERIC_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
Steve French5fdae1f2007-06-05 18:30:44 +0000353 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 disposition = FILE_CREATE;
Steve French5fdae1f2007-06-05 18:30:44 +0000355 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 disposition = FILE_OVERWRITE_IF;
Steve French5fdae1f2007-06-05 18:30:44 +0000357 else if ((oflags & O_CREAT) == O_CREAT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 disposition = FILE_OPEN_IF;
Steve Frenchad7a2922008-02-07 23:25:02 +0000359 else
Steve French5fdae1f2007-06-05 18:30:44 +0000360 cFYI(1, ("Create flag not set in create function"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 }
362
Steve French5fdae1f2007-06-05 18:30:44 +0000363 /* BB add processing to set equivalent of mode - e.g. via CreateX with
364 ACLs */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
Steve French5fdae1f2007-06-05 18:30:44 +0000366 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
367 if (buf == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 kfree(full_path);
369 FreeXid(xid);
370 return -ENOMEM;
371 }
Jeff Layton67750fb2008-05-09 22:28:02 +0000372
Jeff Layton67750fb2008-05-09 22:28:02 +0000373 /*
374 * if we're not using unix extensions, see if we need to set
375 * ATTR_READONLY on the create call
376 */
Steve Frenchf818dd52009-01-19 02:38:35 +0000377 if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
Jeff Layton67750fb2008-05-09 22:28:02 +0000378 create_options |= CREATE_OPTION_READONLY;
379
Steve French5fdae1f2007-06-05 18:30:44 +0000380 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
Steve Frenchf818dd52009-01-19 02:38:35 +0000381 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
Jeff Layton67750fb2008-05-09 22:28:02 +0000382 desiredAccess, create_options,
Steve French737b7582005-04-28 22:41:06 -0700383 &fileHandle, &oplock, buf, cifs_sb->local_nls,
384 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000385 else
386 rc = -EIO; /* no NT SMB support fall into legacy open below */
387
Steve French5fdae1f2007-06-05 18:30:44 +0000388 if (rc == -EIO) {
Steve Frencha9d02ad2005-08-24 23:06:05 -0700389 /* old server, retry the open legacy style */
Steve Frenchf818dd52009-01-19 02:38:35 +0000390 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
Jeff Layton67750fb2008-05-09 22:28:02 +0000391 desiredAccess, create_options,
Steve Frencha9d02ad2005-08-24 23:06:05 -0700392 &fileHandle, &oplock, buf, cifs_sb->local_nls,
393 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5fdae1f2007-06-05 18:30:44 +0000394 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 if (rc) {
Steve French26a21b92006-05-31 18:05:34 +0000396 cFYI(1, ("cifs_create returned 0x%x", rc));
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000397 goto cifs_create_out;
398 }
399
400 /* If Open reported that we actually created a file
401 then we now have to set the mode if possible */
402 if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
403 struct cifs_unix_set_info_args args = {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400404 .mode = mode,
405 .ctime = NO_CHANGE_64,
406 .atime = NO_CHANGE_64,
407 .mtime = NO_CHANGE_64,
408 .device = 0,
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000409 };
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400410
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000411 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
412 args.uid = (__u64) current_fsuid();
413 if (inode->i_mode & S_ISGID)
414 args.gid = (__u64) inode->i_gid;
415 else
416 args.gid = (__u64) current_fsgid();
Steve French3ce53fc2007-06-08 14:55:14 +0000417 } else {
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000418 args.uid = NO_CHANGE_64;
419 args.gid = NO_CHANGE_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 }
Jeff Layton01ea95e2009-07-09 20:02:49 -0400421 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
422 cifs_sb->local_nls,
423 cifs_sb->mnt_cifs_flags &
424 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000425 } else {
426 /* BB implement mode setting via Windows security
427 descriptors e.g. */
428 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000430 /* Could set r/o dos attribute if mode & 0222 == 0 */
431 }
432
433cifs_create_get_file_info:
434 /* server might mask mode so we have to query for it */
435 if (tcon->unix_ext)
436 rc = cifs_get_inode_info_unix(&newinode, full_path,
437 inode->i_sb, xid);
438 else {
439 rc = cifs_get_inode_info(&newinode, full_path, buf,
440 inode->i_sb, xid, &fileHandle);
441 if (newinode) {
442 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
443 newinode->i_mode = mode;
444 if ((oplock & CIFS_CREATE_ACTION) &&
445 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
446 newinode->i_uid = current_fsuid();
447 if (inode->i_mode & S_ISGID)
448 newinode->i_gid = inode->i_gid;
449 else
450 newinode->i_gid = current_fsgid();
Steve French6473a552005-11-29 20:20:10 -0800451 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 }
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000453 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000455cifs_create_set_dentry:
456 if (rc == 0)
457 setup_cifs_dentry(tcon, direntry, newinode);
458 else
459 cFYI(1, ("Create worked, get_inode_info failed rc = %d", rc));
Steve Frenchf818dd52009-01-19 02:38:35 +0000460
Steve Frenchc3b2a0c2009-02-20 04:32:45 +0000461 /* nfsd case - nfs srv does not set nd */
462 if ((nd == NULL) || (!(nd->flags & LOOKUP_OPEN))) {
463 /* mknod case - do not leave file open */
464 CIFSSMBClose(xid, tcon, fileHandle);
Steve French90e4ee52009-05-08 03:04:30 +0000465 } else if (!(posix_create) && (newinode)) {
Jeff Layton086f68b2009-09-21 14:08:18 -0400466 cifs_new_fileinfo(newinode, fileHandle, NULL,
467 nd->path.mnt, oflags);
Steve French5fdae1f2007-06-05 18:30:44 +0000468 }
Steve Frenchd14537f12005-04-28 22:41:05 -0700469cifs_create_out:
470 kfree(buf);
471 kfree(full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 FreeXid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 return rc;
474}
475
Steve French5fdae1f2007-06-05 18:30:44 +0000476int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
477 dev_t device_number)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478{
479 int rc = -EPERM;
480 int xid;
481 struct cifs_sb_info *cifs_sb;
482 struct cifsTconInfo *pTcon;
483 char *full_path = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000484 struct inode *newinode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
486 if (!old_valid_dev(device_number))
487 return -EINVAL;
488
489 xid = GetXid();
490
491 cifs_sb = CIFS_SB(inode->i_sb);
492 pTcon = cifs_sb->tcon;
493
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 full_path = build_path_from_dentry(direntry);
Steve French5fdae1f2007-06-05 18:30:44 +0000495 if (full_path == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 rc = -ENOMEM;
Steve Frenchc18c8422007-07-18 23:21:09 +0000497 else if (pTcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400498 struct cifs_unix_set_info_args args = {
Al Viroce3b0f82009-03-29 19:08:22 -0400499 .mode = mode & ~current_umask(),
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400500 .ctime = NO_CHANGE_64,
501 .atime = NO_CHANGE_64,
502 .mtime = NO_CHANGE_64,
503 .device = device_number,
504 };
Steve French5fdae1f2007-06-05 18:30:44 +0000505 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
David Howellsa001e5b2008-11-14 10:38:47 +1100506 args.uid = (__u64) current_fsuid();
507 args.gid = (__u64) current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 } else {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400509 args.uid = NO_CHANGE_64;
510 args.gid = NO_CHANGE_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 }
Jeff Layton01ea95e2009-07-09 20:02:49 -0400512 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
513 cifs_sb->local_nls,
514 cifs_sb->mnt_cifs_flags &
515 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
Steve French5fdae1f2007-06-05 18:30:44 +0000517 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve French5fdae1f2007-06-05 18:30:44 +0000519 inode->i_sb, xid);
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;
Steve French5fdae1f2007-06-05 18:30:44 +0000524 if (rc == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 d_instantiate(direntry, newinode);
526 }
Steve Frenchd7245c22005-07-14 18:25:12 -0500527 } else {
Steve French5fdae1f2007-06-05 18:30:44 +0000528 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
Steve Frencheda3c0292005-07-21 15:20:28 -0700529 int oplock = 0;
530 u16 fileHandle;
Steve Frenchad7a2922008-02-07 23:25:02 +0000531 FILE_ALL_INFO *buf;
Steve Frenchd7245c22005-07-14 18:25:12 -0500532
Steve French5fdae1f2007-06-05 18:30:44 +0000533 cFYI(1, ("sfu compat create special file"));
Steve Frenchd7245c22005-07-14 18:25:12 -0500534
Steve French5fdae1f2007-06-05 18:30:44 +0000535 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
536 if (buf == NULL) {
Steve Frencheda3c0292005-07-21 15:20:28 -0700537 kfree(full_path);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530538 rc = -ENOMEM;
Steve Frencheda3c0292005-07-21 15:20:28 -0700539 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530540 return rc;
Steve Frencheda3c0292005-07-21 15:20:28 -0700541 }
542
543 rc = CIFSSMBOpen(xid, pTcon, full_path,
544 FILE_CREATE, /* fail if exists */
Steve French5fdae1f2007-06-05 18:30:44 +0000545 GENERIC_WRITE /* BB would
Steve Frencheda3c0292005-07-21 15:20:28 -0700546 WRITE_OWNER | WRITE_DAC be better? */,
547 /* Create a file and set the
548 file attribute to SYSTEM */
549 CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,
550 &fileHandle, &oplock, buf,
551 cifs_sb->local_nls,
Steve French5fdae1f2007-06-05 18:30:44 +0000552 cifs_sb->mnt_cifs_flags &
Steve Frencheda3c0292005-07-21 15:20:28 -0700553 CIFS_MOUNT_MAP_SPECIAL_CHR);
554
Steve French5bafd762006-06-07 00:18:43 +0000555 /* BB FIXME - add handling for backlevel servers
556 which need legacy open and check for all
Steve French5fdae1f2007-06-05 18:30:44 +0000557 calls to SMBOpen for fallback to SMBLeagcyOpen */
558 if (!rc) {
Steve Frencheda3c0292005-07-21 15:20:28 -0700559 /* BB Do not bother to decode buf since no
Steve French86c96b42005-11-18 20:25:31 -0800560 local inode yet to put timestamps in,
561 but we can reuse it safely */
Steve French77159b42007-08-31 01:10:17 +0000562 unsigned int bytes_written;
Steve French86c96b42005-11-18 20:25:31 -0800563 struct win_dev *pdev;
564 pdev = (struct win_dev *)buf;
Steve French5fdae1f2007-06-05 18:30:44 +0000565 if (S_ISCHR(mode)) {
Steve French86c96b42005-11-18 20:25:31 -0800566 memcpy(pdev->type, "IntxCHR", 8);
567 pdev->major =
568 cpu_to_le64(MAJOR(device_number));
Steve French5fdae1f2007-06-05 18:30:44 +0000569 pdev->minor =
Steve French86c96b42005-11-18 20:25:31 -0800570 cpu_to_le64(MINOR(device_number));
571 rc = CIFSSMBWrite(xid, pTcon,
572 fileHandle,
573 sizeof(struct win_dev),
574 0, &bytes_written, (char *)pdev,
575 NULL, 0);
Steve French5fdae1f2007-06-05 18:30:44 +0000576 } else if (S_ISBLK(mode)) {
Steve French86c96b42005-11-18 20:25:31 -0800577 memcpy(pdev->type, "IntxBLK", 8);
578 pdev->major =
579 cpu_to_le64(MAJOR(device_number));
580 pdev->minor =
581 cpu_to_le64(MINOR(device_number));
582 rc = CIFSSMBWrite(xid, pTcon,
583 fileHandle,
584 sizeof(struct win_dev),
585 0, &bytes_written, (char *)pdev,
586 NULL, 0);
587 } /* else if(S_ISFIFO */
Steve Frencheda3c0292005-07-21 15:20:28 -0700588 CIFSSMBClose(xid, pTcon, fileHandle);
589 d_drop(direntry);
590 }
591 kfree(buf);
Steve Frenchd7245c22005-07-14 18:25:12 -0500592 /* add code here to set EAs */
593 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 }
595
Steve Frenchd14537f12005-04-28 22:41:05 -0700596 kfree(full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 FreeXid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 return rc;
599}
600
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601struct dentry *
Steve French5fdae1f2007-06-05 18:30:44 +0000602cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
603 struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604{
605 int xid;
606 int rc = 0; /* to get around spurious gcc warning, set to zero here */
Jeff Layton590a3fe2009-09-12 11:54:28 -0400607 __u32 oplock = 0;
Steve Frencha6ce4932009-04-09 01:14:32 +0000608 __u16 fileHandle = 0;
609 bool posix_open = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 struct cifs_sb_info *cifs_sb;
611 struct cifsTconInfo *pTcon;
612 struct inode *newInode = NULL;
613 char *full_path = NULL;
Steve Frencha6ce4932009-04-09 01:14:32 +0000614 struct file *filp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615
616 xid = GetXid();
617
Steve French61e74802008-12-03 00:57:54 +0000618 cFYI(1, ("parent inode = 0x%p name is: %s and dentry = 0x%p",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 parent_dir_inode, direntry->d_name.name, direntry));
620
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 /* check whether path exists */
622
623 cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
624 pTcon = cifs_sb->tcon;
625
Steve French296034f2006-04-21 18:18:37 +0000626 /*
627 * Don't allow the separator character in a path component.
628 * The VFS will not allow "/", but "\" is allowed by posix.
629 */
630 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
631 int i;
632 for (i = 0; i < direntry->d_name.len; i++)
633 if (direntry->d_name.name[i] == '\\') {
634 cFYI(1, ("Invalid file name"));
635 FreeXid(xid);
636 return ERR_PTR(-EINVAL);
637 }
638 }
639
Jeff Layton5ddf1e02009-07-05 11:01:02 -0400640 /*
641 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
642 * the VFS handle the create.
643 */
Steve French8e6c0332009-11-24 22:17:59 +0000644 if (nd && (nd->flags & LOOKUP_EXCL)) {
Jeff Layton5ddf1e02009-07-05 11:01:02 -0400645 d_instantiate(direntry, NULL);
Steve French2f81e752009-11-25 00:11:31 +0000646 return NULL;
Jeff Layton5ddf1e02009-07-05 11:01:02 -0400647 }
648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 /* can not grab the rename sem here since it would
650 deadlock in the cases (beginning of sys_rename itself)
651 in which we already have the sb rename sem */
652 full_path = build_path_from_dentry(direntry);
Steve French5fdae1f2007-06-05 18:30:44 +0000653 if (full_path == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 FreeXid(xid);
655 return ERR_PTR(-ENOMEM);
656 }
657
658 if (direntry->d_inode != NULL) {
Steve French61e74802008-12-03 00:57:54 +0000659 cFYI(1, ("non-NULL inode in lookup"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 } else {
Steve French61e74802008-12-03 00:57:54 +0000661 cFYI(1, ("NULL inode in lookup"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 }
Steve French61e74802008-12-03 00:57:54 +0000663 cFYI(1, ("Full path: %s inode = 0x%p", full_path, direntry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Steve French8db14ca2009-05-23 18:57:25 +0000665 /* Posix open is only called (at lookup time) for file create now.
666 * For opens (rather than creates), because we do not know if it
667 * is a file or directory yet, and current Samba no longer allows
668 * us to do posix open on dirs, we could end up wasting an open call
669 * on what turns out to be a dir. For file opens, we wait to call posix
670 * open till cifs_open. It could be added here (lookup) in the future
671 * but the performance tradeoff of the extra network request when EISDIR
672 * or EACCES is returned would have to be weighed against the 50%
673 * reduction in network traffic in the other paths.
674 */
Steve Frencha6ce4932009-04-09 01:14:32 +0000675 if (pTcon->unix_ext) {
Steve French8e6c0332009-11-24 22:17:59 +0000676 if (nd && !(nd->flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY)) &&
Steve French8db14ca2009-05-23 18:57:25 +0000677 (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
678 (nd->intent.open.flags & O_CREAT)) {
Jeff Layton3bc303c2009-09-21 06:47:50 -0400679 rc = cifs_posix_open(full_path, &newInode, nd->path.mnt,
Steve French703a3b82009-05-21 22:21:53 +0000680 nd->intent.open.create_mode,
Steve Frencha6ce4932009-04-09 01:14:32 +0000681 nd->intent.open.flags, &oplock,
682 &fileHandle, xid);
Steve French8db14ca2009-05-23 18:57:25 +0000683 /*
684 * The check below works around a bug in POSIX
685 * open in samba versions 3.3.1 and earlier where
686 * open could incorrectly fail with invalid parameter.
687 * If either that or op not supported returned, follow
688 * the normal lookup.
689 */
690 if ((rc == 0) || (rc == -ENOENT))
691 posix_open = true;
692 else if ((rc == -EINVAL) || (rc != -EOPNOTSUPP))
693 pTcon->broken_posix_open = true;
Steve Frencha6ce4932009-04-09 01:14:32 +0000694 }
695 if (!posix_open)
696 rc = cifs_get_inode_info_unix(&newInode, full_path,
697 parent_dir_inode->i_sb, xid);
698 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 rc = cifs_get_inode_info(&newInode, full_path, NULL,
Steve Frencha6ce4932009-04-09 01:14:32 +0000700 parent_dir_inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
702 if ((rc == 0) && (newInode != NULL)) {
Steve Frenchb92327f2005-08-22 20:09:43 -0700703 if (pTcon->nocase)
704 direntry->d_op = &cifs_ci_dentry_ops;
705 else
706 direntry->d_op = &cifs_dentry_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 d_add(direntry, newInode);
Steve Frencha6ce4932009-04-09 01:14:32 +0000708 if (posix_open)
709 filp = lookup_instantiate_filp(nd, direntry, NULL);
Steve French5fdae1f2007-06-05 18:30:44 +0000710 /* since paths are not looked up by component - the parent
Steve French3abb9272005-11-28 08:16:13 -0800711 directories are presumed to be good here */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 renew_parental_timestamps(direntry);
713
714 } else if (rc == -ENOENT) {
715 rc = 0;
Steve French3abb9272005-11-28 08:16:13 -0800716 direntry->d_time = jiffies;
717 if (pTcon->nocase)
718 direntry->d_op = &cifs_ci_dentry_ops;
719 else
720 direntry->d_op = &cifs_dentry_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 d_add(direntry, NULL);
Steve French5fdae1f2007-06-05 18:30:44 +0000722 /* if it was once a directory (but how can we tell?) we could do
723 shrink_dcache_parent(direntry); */
Steve Frenched2b9172008-01-20 00:30:29 +0000724 } else if (rc != -EACCES) {
725 cERROR(1, ("Unexpected lookup error %d", rc));
726 /* We special case check for Access Denied - since that
727 is a common return code */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 }
729
Steve Frenchd14537f12005-04-28 22:41:05 -0700730 kfree(full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 FreeXid(xid);
732 return ERR_PTR(rc);
733}
734
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735static int
736cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
737{
738 int isValid = 1;
739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 if (direntry->d_inode) {
Steve Frenchad7a2922008-02-07 23:25:02 +0000741 if (cifs_revalidate(direntry))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 } else {
Steve French3abb9272005-11-28 08:16:13 -0800744 cFYI(1, ("neg dentry 0x%p name = %s",
745 direntry, direntry->d_name.name));
Steve French5fdae1f2007-06-05 18:30:44 +0000746 if (time_after(jiffies, direntry->d_time + HZ) ||
Steve French3abb9272005-11-28 08:16:13 -0800747 !lookupCacheEnabled) {
748 d_drop(direntry);
749 isValid = 0;
Steve French5fdae1f2007-06-05 18:30:44 +0000750 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 }
752
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 return isValid;
754}
755
756/* static int cifs_d_delete(struct dentry *direntry)
757{
758 int rc = 0;
759
760 cFYI(1, ("In cifs d_delete, name = %s", direntry->d_name.name));
761
762 return rc;
763} */
764
Al Viro4fd03e82009-02-20 05:57:07 +0000765const struct dentry_operations cifs_dentry_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 .d_revalidate = cifs_d_revalidate,
Steve French5fdae1f2007-06-05 18:30:44 +0000767/* d_delete: cifs_d_delete, */ /* not needed except for debugging */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768};
Steve Frenchb92327f2005-08-22 20:09:43 -0700769
770static int cifs_ci_hash(struct dentry *dentry, struct qstr *q)
771{
772 struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
773 unsigned long hash;
774 int i;
775
776 hash = init_name_hash();
777 for (i = 0; i < q->len; i++)
778 hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
779 hash);
780 q->hash = end_name_hash(hash);
781
782 return 0;
783}
784
785static int cifs_ci_compare(struct dentry *dentry, struct qstr *a,
786 struct qstr *b)
787{
788 struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
789
790 if ((a->len == b->len) &&
791 (nls_strnicmp(codepage, a->name, b->name, a->len) == 0)) {
792 /*
793 * To preserve case, don't let an existing negative dentry's
794 * case take precedence. If a is not a negative dentry, this
795 * should have no side effects
796 */
Steve Frenchc3291632008-05-15 05:41:54 +0000797 memcpy((void *)a->name, b->name, a->len);
Steve Frenchb92327f2005-08-22 20:09:43 -0700798 return 0;
799 }
800 return 1;
801}
802
Al Viro4fd03e82009-02-20 05:57:07 +0000803const struct dentry_operations cifs_ci_dentry_ops = {
Steve Frenchb92327f2005-08-22 20:09:43 -0700804 .d_revalidate = cifs_d_revalidate,
805 .d_hash = cifs_ci_hash,
806 .d_compare = cifs_ci_compare,
807};