no need to check for LOOKUP_OPEN in ->create() instances
[linux-3.10.git] / fs / cifs / dir.c
1 /*
2  *   fs/cifs/dir.c
3  *
4  *   vfs operations that deal with dentries
5  *
6  *   Copyright (C) International Business Machines  Corp., 2002,2009
7  *   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 <linux/mount.h>
28 #include <linux/file.h>
29 #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
36 static void
37 renew_parental_timestamps(struct dentry *direntry)
38 {
39         /* BB check if there is a way to get the kernel to do this or if we
40            really need this */
41         do {
42                 direntry->d_time = jiffies;
43                 direntry = direntry->d_parent;
44         } while (!IS_ROOT(direntry));
45 }
46
47 /* Note: caller must free return buffer */
48 char *
49 build_path_from_dentry(struct dentry *direntry)
50 {
51         struct dentry *temp;
52         int namelen;
53         int dfsplen;
54         char *full_path;
55         char dirsep;
56         struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
57         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
58         unsigned seq;
59
60         if (direntry == NULL)
61                 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
65         dirsep = CIFS_DIR_SEP(cifs_sb);
66         if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
67                 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
68         else
69                 dfsplen = 0;
70 cifs_bp_rename_retry:
71         namelen = dfsplen;
72         seq = read_seqbegin(&rename_lock);
73         rcu_read_lock();
74         for (temp = direntry; !IS_ROOT(temp);) {
75                 namelen += (1 + temp->d_name.len);
76                 temp = temp->d_parent;
77                 if (temp == NULL) {
78                         cERROR(1, "corrupt dentry");
79                         rcu_read_unlock();
80                         return NULL;
81                 }
82         }
83         rcu_read_unlock();
84
85         full_path = kmalloc(namelen+1, GFP_KERNEL);
86         if (full_path == NULL)
87                 return full_path;
88         full_path[namelen] = 0; /* trailing null */
89         rcu_read_lock();
90         for (temp = direntry; !IS_ROOT(temp);) {
91                 spin_lock(&temp->d_lock);
92                 namelen -= 1 + temp->d_name.len;
93                 if (namelen < 0) {
94                         spin_unlock(&temp->d_lock);
95                         break;
96                 } else {
97                         full_path[namelen] = dirsep;
98                         strncpy(full_path + namelen + 1, temp->d_name.name,
99                                 temp->d_name.len);
100                         cFYI(0, "name: %s", full_path + namelen);
101                 }
102                 spin_unlock(&temp->d_lock);
103                 temp = temp->d_parent;
104                 if (temp == NULL) {
105                         cERROR(1, "corrupt dentry");
106                         rcu_read_unlock();
107                         kfree(full_path);
108                         return NULL;
109                 }
110         }
111         rcu_read_unlock();
112         if (namelen != dfsplen || read_seqretry(&rename_lock, seq)) {
113                 cERROR(1, "did not end path lookup where expected namelen is %d",
114                         namelen);
115                 /* presumably this is only possible if racing with a rename
116                 of one of the parent directories  (we can not lock the dentries
117                 above us to prevent this, but retrying should be harmless) */
118                 kfree(full_path);
119                 goto cifs_bp_rename_retry;
120         }
121         /* DIR_SEP already set for byte  0 / vs \ but not for
122            subsequent slashes in prepath which currently must
123            be entered the right way - not sure if there is an alternative
124            since the '\' is a valid posix character so we can not switch
125            those safely to '/' if any are found in the middle of the prepath */
126         /* BB test paths to Windows with '/' in the midst of prepath */
127
128         if (dfsplen) {
129                 strncpy(full_path, tcon->treeName, dfsplen);
130                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
131                         int i;
132                         for (i = 0; i < dfsplen; i++) {
133                                 if (full_path[i] == '\\')
134                                         full_path[i] = '/';
135                         }
136                 }
137         }
138         return full_path;
139 }
140
141 /* Inode operations in similar order to how they appear in Linux file fs.h */
142
143 int
144 cifs_create(struct inode *inode, struct dentry *direntry, int mode,
145                 struct nameidata *nd)
146 {
147         int rc = -ENOENT;
148         int xid;
149         int create_options = CREATE_NOT_DIR;
150         __u32 oplock = 0;
151         int oflags;
152         /*
153          * BB below access is probably too much for mknod to request
154          *    but we have to do query and setpathinfo so requesting
155          *    less could fail (unless we want to request getatr and setatr
156          *    permissions (only).  At least for POSIX we do not have to
157          *    request so much.
158          */
159         int desiredAccess = GENERIC_READ | GENERIC_WRITE;
160         __u16 fileHandle;
161         struct cifs_sb_info *cifs_sb;
162         struct tcon_link *tlink;
163         struct cifs_tcon *tcon;
164         char *full_path = NULL;
165         FILE_ALL_INFO *buf = NULL;
166         struct inode *newinode = NULL;
167         int disposition = FILE_OVERWRITE_IF;
168
169         xid = GetXid();
170
171         cifs_sb = CIFS_SB(inode->i_sb);
172         tlink = cifs_sb_tlink(cifs_sb);
173         if (IS_ERR(tlink)) {
174                 FreeXid(xid);
175                 return PTR_ERR(tlink);
176         }
177         tcon = tlink_tcon(tlink);
178
179         if (oplockEnabled)
180                 oplock = REQ_OPLOCK;
181
182         if (nd)
183                 oflags = nd->intent.open.file->f_flags;
184         else
185                 oflags = O_RDONLY | O_CREAT;
186
187         full_path = build_path_from_dentry(direntry);
188         if (full_path == NULL) {
189                 rc = -ENOMEM;
190                 goto cifs_create_out;
191         }
192
193         if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
194             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
195                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
196                 rc = cifs_posix_open(full_path, &newinode,
197                         inode->i_sb, mode, oflags, &oplock, &fileHandle, xid);
198                 /* EIO could indicate that (posix open) operation is not
199                    supported, despite what server claimed in capability
200                    negotiation.  EREMOTE indicates DFS junction, which is not
201                    handled in posix open */
202
203                 if (rc == 0) {
204                         if (newinode == NULL) /* query inode info */
205                                 goto cifs_create_get_file_info;
206                         else /* success, no need to query */
207                                 goto cifs_create_set_dentry;
208                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
209                          (rc != -EOPNOTSUPP) && (rc != -EINVAL))
210                         goto cifs_create_out;
211                 /* else fallthrough to retry, using older open call, this is
212                    case where server does not support this SMB level, and
213                    falsely claims capability (also get here for DFS case
214                    which should be rare for path not covered on files) */
215         }
216
217         if (nd) {
218                 /* if the file is going to stay open, then we
219                    need to set the desired access properly */
220                 desiredAccess = 0;
221                 if (OPEN_FMODE(oflags) & FMODE_READ)
222                         desiredAccess |= GENERIC_READ; /* is this too little? */
223                 if (OPEN_FMODE(oflags) & FMODE_WRITE)
224                         desiredAccess |= GENERIC_WRITE;
225
226                 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
227                         disposition = FILE_CREATE;
228                 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
229                         disposition = FILE_OVERWRITE_IF;
230                 else if ((oflags & O_CREAT) == O_CREAT)
231                         disposition = FILE_OPEN_IF;
232                 else
233                         cFYI(1, "Create flag not set in create function");
234         }
235
236         /* BB add processing to set equivalent of mode - e.g. via CreateX with
237            ACLs */
238
239         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
240         if (buf == NULL) {
241                 rc = -ENOMEM;
242                 goto cifs_create_out;
243         }
244
245         /*
246          * if we're not using unix extensions, see if we need to set
247          * ATTR_READONLY on the create call
248          */
249         if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
250                 create_options |= CREATE_OPTION_READONLY;
251
252         if (tcon->ses->capabilities & CAP_NT_SMBS)
253                 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
254                          desiredAccess, create_options,
255                          &fileHandle, &oplock, buf, cifs_sb->local_nls,
256                          cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
257         else
258                 rc = -EIO; /* no NT SMB support fall into legacy open below */
259
260         if (rc == -EIO) {
261                 /* old server, retry the open legacy style */
262                 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
263                         desiredAccess, create_options,
264                         &fileHandle, &oplock, buf, cifs_sb->local_nls,
265                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
266         }
267         if (rc) {
268                 cFYI(1, "cifs_create returned 0x%x", rc);
269                 goto cifs_create_out;
270         }
271
272         /* If Open reported that we actually created a file
273            then we now have to set the mode if possible */
274         if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
275                 struct cifs_unix_set_info_args args = {
276                                 .mode   = mode,
277                                 .ctime  = NO_CHANGE_64,
278                                 .atime  = NO_CHANGE_64,
279                                 .mtime  = NO_CHANGE_64,
280                                 .device = 0,
281                 };
282
283                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
284                         args.uid = (__u64) current_fsuid();
285                         if (inode->i_mode & S_ISGID)
286                                 args.gid = (__u64) inode->i_gid;
287                         else
288                                 args.gid = (__u64) current_fsgid();
289                 } else {
290                         args.uid = NO_CHANGE_64;
291                         args.gid = NO_CHANGE_64;
292                 }
293                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fileHandle,
294                                         current->tgid);
295         } else {
296                 /* BB implement mode setting via Windows security
297                    descriptors e.g. */
298                 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
299
300                 /* Could set r/o dos attribute if mode & 0222 == 0 */
301         }
302
303 cifs_create_get_file_info:
304         /* server might mask mode so we have to query for it */
305         if (tcon->unix_ext)
306                 rc = cifs_get_inode_info_unix(&newinode, full_path,
307                                               inode->i_sb, xid);
308         else {
309                 rc = cifs_get_inode_info(&newinode, full_path, buf,
310                                          inode->i_sb, xid, &fileHandle);
311                 if (newinode) {
312                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
313                                 newinode->i_mode = mode;
314                         if ((oplock & CIFS_CREATE_ACTION) &&
315                             (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
316                                 newinode->i_uid = current_fsuid();
317                                 if (inode->i_mode & S_ISGID)
318                                         newinode->i_gid = inode->i_gid;
319                                 else
320                                         newinode->i_gid = current_fsgid();
321                         }
322                 }
323         }
324
325 cifs_create_set_dentry:
326         if (rc == 0)
327                 d_instantiate(direntry, newinode);
328         else
329                 cFYI(1, "Create worked, get_inode_info failed rc = %d", rc);
330
331         if (newinode && nd) {
332                 struct cifsFileInfo *pfile_info;
333                 struct file *filp;
334
335                 filp = lookup_instantiate_filp(nd, direntry, generic_file_open);
336                 if (IS_ERR(filp)) {
337                         rc = PTR_ERR(filp);
338                         CIFSSMBClose(xid, tcon, fileHandle);
339                         goto cifs_create_out;
340                 }
341
342                 pfile_info = cifs_new_fileinfo(fileHandle, filp, tlink, oplock);
343                 if (pfile_info == NULL) {
344                         fput(filp);
345                         CIFSSMBClose(xid, tcon, fileHandle);
346                         rc = -ENOMEM;
347                 }
348         } else {
349                 CIFSSMBClose(xid, tcon, fileHandle);
350         }
351
352 cifs_create_out:
353         kfree(buf);
354         kfree(full_path);
355         cifs_put_tlink(tlink);
356         FreeXid(xid);
357         return rc;
358 }
359
360 int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
361                 dev_t device_number)
362 {
363         int rc = -EPERM;
364         int xid;
365         struct cifs_sb_info *cifs_sb;
366         struct tcon_link *tlink;
367         struct cifs_tcon *pTcon;
368         struct cifs_io_parms io_parms;
369         char *full_path = NULL;
370         struct inode *newinode = NULL;
371         int oplock = 0;
372         u16 fileHandle;
373         FILE_ALL_INFO *buf = NULL;
374         unsigned int bytes_written;
375         struct win_dev *pdev;
376
377         if (!old_valid_dev(device_number))
378                 return -EINVAL;
379
380         cifs_sb = CIFS_SB(inode->i_sb);
381         tlink = cifs_sb_tlink(cifs_sb);
382         if (IS_ERR(tlink))
383                 return PTR_ERR(tlink);
384
385         pTcon = tlink_tcon(tlink);
386
387         xid = GetXid();
388
389         full_path = build_path_from_dentry(direntry);
390         if (full_path == NULL) {
391                 rc = -ENOMEM;
392                 goto mknod_out;
393         }
394
395         if (pTcon->unix_ext) {
396                 struct cifs_unix_set_info_args args = {
397                         .mode   = mode & ~current_umask(),
398                         .ctime  = NO_CHANGE_64,
399                         .atime  = NO_CHANGE_64,
400                         .mtime  = NO_CHANGE_64,
401                         .device = device_number,
402                 };
403                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
404                         args.uid = (__u64) current_fsuid();
405                         args.gid = (__u64) current_fsgid();
406                 } else {
407                         args.uid = NO_CHANGE_64;
408                         args.gid = NO_CHANGE_64;
409                 }
410                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
411                                             cifs_sb->local_nls,
412                                             cifs_sb->mnt_cifs_flags &
413                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
414                 if (rc)
415                         goto mknod_out;
416
417                 rc = cifs_get_inode_info_unix(&newinode, full_path,
418                                                 inode->i_sb, xid);
419
420                 if (rc == 0)
421                         d_instantiate(direntry, newinode);
422                 goto mknod_out;
423         }
424
425         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
426                 goto mknod_out;
427
428
429         cFYI(1, "sfu compat create special file");
430
431         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
432         if (buf == NULL) {
433                 kfree(full_path);
434                 rc = -ENOMEM;
435                 FreeXid(xid);
436                 return rc;
437         }
438
439         /* FIXME: would WRITE_OWNER | WRITE_DAC be better? */
440         rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_CREATE,
441                          GENERIC_WRITE, CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,
442                          &fileHandle, &oplock, buf, cifs_sb->local_nls,
443                          cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
444         if (rc)
445                 goto mknod_out;
446
447         /* BB Do not bother to decode buf since no local inode yet to put
448          * timestamps in, but we can reuse it safely */
449
450         pdev = (struct win_dev *)buf;
451         io_parms.netfid = fileHandle;
452         io_parms.pid = current->tgid;
453         io_parms.tcon = pTcon;
454         io_parms.offset = 0;
455         io_parms.length = sizeof(struct win_dev);
456         if (S_ISCHR(mode)) {
457                 memcpy(pdev->type, "IntxCHR", 8);
458                 pdev->major =
459                       cpu_to_le64(MAJOR(device_number));
460                 pdev->minor =
461                       cpu_to_le64(MINOR(device_number));
462                 rc = CIFSSMBWrite(xid, &io_parms,
463                         &bytes_written, (char *)pdev,
464                         NULL, 0);
465         } else if (S_ISBLK(mode)) {
466                 memcpy(pdev->type, "IntxBLK", 8);
467                 pdev->major =
468                       cpu_to_le64(MAJOR(device_number));
469                 pdev->minor =
470                       cpu_to_le64(MINOR(device_number));
471                 rc = CIFSSMBWrite(xid, &io_parms,
472                         &bytes_written, (char *)pdev,
473                         NULL, 0);
474         } /* else if (S_ISFIFO) */
475         CIFSSMBClose(xid, pTcon, fileHandle);
476         d_drop(direntry);
477
478         /* FIXME: add code here to set EAs */
479
480 mknod_out:
481         kfree(full_path);
482         kfree(buf);
483         FreeXid(xid);
484         cifs_put_tlink(tlink);
485         return rc;
486 }
487
488 struct dentry *
489 cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
490             struct nameidata *nd)
491 {
492         int xid;
493         int rc = 0; /* to get around spurious gcc warning, set to zero here */
494         __u32 oplock = 0;
495         __u16 fileHandle = 0;
496         bool posix_open = false;
497         struct cifs_sb_info *cifs_sb;
498         struct tcon_link *tlink;
499         struct cifs_tcon *pTcon;
500         struct cifsFileInfo *cfile;
501         struct inode *newInode = NULL;
502         char *full_path = NULL;
503         struct file *filp;
504
505         xid = GetXid();
506
507         cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
508               parent_dir_inode, direntry->d_name.name, direntry);
509
510         /* check whether path exists */
511
512         cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
513         tlink = cifs_sb_tlink(cifs_sb);
514         if (IS_ERR(tlink)) {
515                 FreeXid(xid);
516                 return (struct dentry *)tlink;
517         }
518         pTcon = tlink_tcon(tlink);
519
520         /*
521          * Don't allow the separator character in a path component.
522          * The VFS will not allow "/", but "\" is allowed by posix.
523          */
524         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
525                 int i;
526                 for (i = 0; i < direntry->d_name.len; i++)
527                         if (direntry->d_name.name[i] == '\\') {
528                                 cFYI(1, "Invalid file name");
529                                 rc = -EINVAL;
530                                 goto lookup_out;
531                         }
532         }
533
534         /*
535          * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
536          * the VFS handle the create.
537          */
538         if (nd && (nd->flags & LOOKUP_EXCL)) {
539                 d_instantiate(direntry, NULL);
540                 rc = 0;
541                 goto lookup_out;
542         }
543
544         /* can not grab the rename sem here since it would
545         deadlock in the cases (beginning of sys_rename itself)
546         in which we already have the sb rename sem */
547         full_path = build_path_from_dentry(direntry);
548         if (full_path == NULL) {
549                 rc = -ENOMEM;
550                 goto lookup_out;
551         }
552
553         if (direntry->d_inode != NULL) {
554                 cFYI(1, "non-NULL inode in lookup");
555         } else {
556                 cFYI(1, "NULL inode in lookup");
557         }
558         cFYI(1, "Full path: %s inode = 0x%p", full_path, direntry->d_inode);
559
560         /* Posix open is only called (at lookup time) for file create now.
561          * For opens (rather than creates), because we do not know if it
562          * is a file or directory yet, and current Samba no longer allows
563          * us to do posix open on dirs, we could end up wasting an open call
564          * on what turns out to be a dir. For file opens, we wait to call posix
565          * open till cifs_open.  It could be added here (lookup) in the future
566          * but the performance tradeoff of the extra network request when EISDIR
567          * or EACCES is returned would have to be weighed against the 50%
568          * reduction in network traffic in the other paths.
569          */
570         if (pTcon->unix_ext) {
571                 if (nd && !(nd->flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY)) &&
572                      (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
573                      (nd->intent.open.file->f_flags & O_CREAT)) {
574                         rc = cifs_posix_open(full_path, &newInode,
575                                         parent_dir_inode->i_sb,
576                                         nd->intent.open.create_mode,
577                                         nd->intent.open.file->f_flags, &oplock,
578                                         &fileHandle, xid);
579                         /*
580                          * The check below works around a bug in POSIX
581                          * open in samba versions 3.3.1 and earlier where
582                          * open could incorrectly fail with invalid parameter.
583                          * If either that or op not supported returned, follow
584                          * the normal lookup.
585                          */
586                         if ((rc == 0) || (rc == -ENOENT))
587                                 posix_open = true;
588                         else if ((rc == -EINVAL) || (rc != -EOPNOTSUPP))
589                                 pTcon->broken_posix_open = true;
590                 }
591                 if (!posix_open)
592                         rc = cifs_get_inode_info_unix(&newInode, full_path,
593                                                 parent_dir_inode->i_sb, xid);
594         } else
595                 rc = cifs_get_inode_info(&newInode, full_path, NULL,
596                                 parent_dir_inode->i_sb, xid, NULL);
597
598         if ((rc == 0) && (newInode != NULL)) {
599                 d_add(direntry, newInode);
600                 if (posix_open) {
601                         filp = lookup_instantiate_filp(nd, direntry,
602                                                        generic_file_open);
603                         if (IS_ERR(filp)) {
604                                 rc = PTR_ERR(filp);
605                                 CIFSSMBClose(xid, pTcon, fileHandle);
606                                 goto lookup_out;
607                         }
608
609                         cfile = cifs_new_fileinfo(fileHandle, filp, tlink,
610                                                   oplock);
611                         if (cfile == NULL) {
612                                 fput(filp);
613                                 CIFSSMBClose(xid, pTcon, fileHandle);
614                                 rc = -ENOMEM;
615                                 goto lookup_out;
616                         }
617                 }
618                 /* since paths are not looked up by component - the parent
619                    directories are presumed to be good here */
620                 renew_parental_timestamps(direntry);
621
622         } else if (rc == -ENOENT) {
623                 rc = 0;
624                 direntry->d_time = jiffies;
625                 d_add(direntry, NULL);
626         /*      if it was once a directory (but how can we tell?) we could do
627                 shrink_dcache_parent(direntry); */
628         } else if (rc != -EACCES) {
629                 cERROR(1, "Unexpected lookup error %d", rc);
630                 /* We special case check for Access Denied - since that
631                 is a common return code */
632         }
633
634 lookup_out:
635         kfree(full_path);
636         cifs_put_tlink(tlink);
637         FreeXid(xid);
638         return ERR_PTR(rc);
639 }
640
641 static int
642 cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
643 {
644         if (nd->flags & LOOKUP_RCU)
645                 return -ECHILD;
646
647         if (direntry->d_inode) {
648                 if (cifs_revalidate_dentry(direntry))
649                         return 0;
650                 else
651                         return 1;
652         }
653
654         /*
655          * This may be nfsd (or something), anyway, we can't see the
656          * intent of this. So, since this can be for creation, drop it.
657          */
658         if (!nd)
659                 return 0;
660
661         /*
662          * Drop the negative dentry, in order to make sure to use the
663          * case sensitive name which is specified by user if this is
664          * for creation.
665          */
666         if (!(nd->flags & (LOOKUP_CONTINUE | LOOKUP_PARENT))) {
667                 if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
668                         return 0;
669         }
670
671         if (time_after(jiffies, direntry->d_time + HZ) || !lookupCacheEnabled)
672                 return 0;
673
674         return 1;
675 }
676
677 /* static int cifs_d_delete(struct dentry *direntry)
678 {
679         int rc = 0;
680
681         cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
682
683         return rc;
684 }     */
685
686 const struct dentry_operations cifs_dentry_ops = {
687         .d_revalidate = cifs_d_revalidate,
688         .d_automount = cifs_dfs_d_automount,
689 /* d_delete:       cifs_d_delete,      */ /* not needed except for debugging */
690 };
691
692 static int cifs_ci_hash(const struct dentry *dentry, const struct inode *inode,
693                 struct qstr *q)
694 {
695         struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
696         unsigned long hash;
697         int i;
698
699         hash = init_name_hash();
700         for (i = 0; i < q->len; i++)
701                 hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
702                                          hash);
703         q->hash = end_name_hash(hash);
704
705         return 0;
706 }
707
708 static int cifs_ci_compare(const struct dentry *parent,
709                 const struct inode *pinode,
710                 const struct dentry *dentry, const struct inode *inode,
711                 unsigned int len, const char *str, const struct qstr *name)
712 {
713         struct nls_table *codepage = CIFS_SB(pinode->i_sb)->local_nls;
714
715         if ((name->len == len) &&
716             (nls_strnicmp(codepage, name->name, str, len) == 0))
717                 return 0;
718         return 1;
719 }
720
721 const struct dentry_operations cifs_ci_dentry_ops = {
722         .d_revalidate = cifs_d_revalidate,
723         .d_hash = cifs_ci_hash,
724         .d_compare = cifs_ci_compare,
725         .d_automount = cifs_dfs_d_automount,
726 };