OMAP3 SRF: Generic shared resource f/w
[linux-ginger.git] / fs / cifs / dir.c
blob627a60a6c1b11078c33c37503afcd8061f4ff428
1 /*
2 * fs/cifs/dir.c
4 * vfs operations that deal with dentries
6 * Copyright (C) International Business Machines Corp., 2002,2009
7 * Author(s): Steve French (sfrench@us.ibm.com)
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.
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.
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
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 "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"
35 static void
36 renew_parental_timestamps(struct dentry *direntry)
38 /* BB check if there is a way to get the kernel to do this or if we
39 really need this */
40 do {
41 direntry->d_time = jiffies;
42 direntry = direntry->d_parent;
43 } while (!IS_ROOT(direntry));
46 /* Note: caller must free return buffer */
47 char *
48 build_path_from_dentry(struct dentry *direntry)
50 struct dentry *temp;
51 int namelen;
52 int pplen;
53 int dfsplen;
54 char *full_path;
55 char dirsep;
56 struct cifs_sb_info *cifs_sb;
58 if (direntry == NULL)
59 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 */
63 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;
70 cifs_bp_rename_retry:
71 namelen = pplen + dfsplen;
72 for (temp = direntry; !IS_ROOT(temp);) {
73 namelen += (1 + temp->d_name.len);
74 temp = temp->d_parent;
75 if (temp == NULL) {
76 cERROR(1, ("corrupt dentry"));
77 return NULL;
81 full_path = kmalloc(namelen+1, GFP_KERNEL);
82 if (full_path == NULL)
83 return full_path;
84 full_path[namelen] = 0; /* trailing null */
85 for (temp = direntry; !IS_ROOT(temp);) {
86 namelen -= 1 + temp->d_name.len;
87 if (namelen < 0) {
88 break;
89 } else {
90 full_path[namelen] = dirsep;
91 strncpy(full_path + namelen + 1, temp->d_name.name,
92 temp->d_name.len);
93 cFYI(0, ("name: %s", full_path + namelen));
95 temp = temp->d_parent;
96 if (temp == NULL) {
97 cERROR(1, ("corrupt dentry"));
98 kfree(full_path);
99 return NULL;
102 if (namelen != pplen + dfsplen) {
103 cERROR(1,
104 ("did not end path lookup where expected namelen is %d",
105 namelen));
106 /* presumably this is only possible if racing with a rename
107 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);
110 goto cifs_bp_rename_retry;
112 /* 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 */
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] = '/';
129 strncpy(full_path + dfsplen, CIFS_SB(direntry->d_sb)->prepath, pplen);
130 return full_path;
133 struct cifsFileInfo *
134 cifs_new_fileinfo(struct inode *newinode, __u16 fileHandle,
135 struct file *file, struct vfsmount *mnt, unsigned int oflags)
137 int oplock = 0;
138 struct cifsFileInfo *pCifsFile;
139 struct cifsInodeInfo *pCifsInode;
140 struct cifs_sb_info *cifs_sb = CIFS_SB(mnt->mnt_sb);
142 pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
143 if (pCifsFile == NULL)
144 return pCifsFile;
146 if (oplockEnabled)
147 oplock = REQ_OPLOCK;
149 pCifsFile->netfid = fileHandle;
150 pCifsFile->pid = current->tgid;
151 pCifsFile->pInode = igrab(newinode);
152 pCifsFile->mnt = mnt;
153 pCifsFile->pfile = file;
154 pCifsFile->invalidHandle = false;
155 pCifsFile->closePend = false;
156 mutex_init(&pCifsFile->fh_mutex);
157 mutex_init(&pCifsFile->lock_mutex);
158 INIT_LIST_HEAD(&pCifsFile->llist);
159 atomic_set(&pCifsFile->count, 1);
160 slow_work_init(&pCifsFile->oplock_break, &cifs_oplock_break_ops);
162 write_lock(&GlobalSMBSeslock);
163 list_add(&pCifsFile->tlist, &cifs_sb->tcon->openFileList);
164 pCifsInode = CIFS_I(newinode);
165 if (pCifsInode) {
166 /* if readable file instance put first in list*/
167 if (oflags & FMODE_READ)
168 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
169 else
170 list_add_tail(&pCifsFile->flist,
171 &pCifsInode->openFileList);
173 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
174 pCifsInode->clientCanCacheAll = true;
175 pCifsInode->clientCanCacheRead = true;
176 cFYI(1, ("Exclusive Oplock inode %p", newinode));
177 } else if ((oplock & 0xF) == OPLOCK_READ)
178 pCifsInode->clientCanCacheRead = true;
180 write_unlock(&GlobalSMBSeslock);
182 return pCifsFile;
185 int cifs_posix_open(char *full_path, struct inode **pinode,
186 struct vfsmount *mnt, int mode, int oflags,
187 __u32 *poplock, __u16 *pnetfid, int xid)
189 int rc;
190 FILE_UNIX_BASIC_INFO *presp_data;
191 __u32 posix_flags = 0;
192 struct cifs_sb_info *cifs_sb = CIFS_SB(mnt->mnt_sb);
193 struct cifs_fattr fattr;
195 cFYI(1, ("posix open %s", full_path));
197 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
198 if (presp_data == NULL)
199 return -ENOMEM;
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;
217 if (oflags & O_APPEND)
218 posix_flags |= SMB_O_APPEND;
219 if (oflags & O_SYNC)
220 posix_flags |= SMB_O_SYNC;
221 if (oflags & O_DIRECTORY)
222 posix_flags |= SMB_O_DIRECTORY;
223 if (oflags & O_NOFOLLOW)
224 posix_flags |= SMB_O_NOFOLLOW;
225 if (oflags & O_DIRECT)
226 posix_flags |= SMB_O_DIRECT;
228 mode &= ~current_umask();
229 rc = CIFSPOSIXCreate(xid, cifs_sb->tcon, posix_flags, mode,
230 pnetfid, presp_data, poplock, full_path,
231 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
232 CIFS_MOUNT_MAP_SPECIAL_CHR);
233 if (rc)
234 goto posix_open_ret;
236 if (presp_data->Type == cpu_to_le32(-1))
237 goto posix_open_ret; /* open ok, caller does qpathinfo */
239 if (!pinode)
240 goto posix_open_ret; /* caller does not need info */
242 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
244 /* get new inode and set it up */
245 if (*pinode == NULL) {
246 *pinode = cifs_iget(mnt->mnt_sb, &fattr);
247 if (!*pinode) {
248 rc = -ENOMEM;
249 goto posix_open_ret;
251 } else {
252 cifs_fattr_to_inode(*pinode, &fattr);
255 cifs_new_fileinfo(*pinode, *pnetfid, NULL, mnt, oflags);
257 posix_open_ret:
258 kfree(presp_data);
259 return rc;
262 static void setup_cifs_dentry(struct cifsTconInfo *tcon,
263 struct dentry *direntry,
264 struct inode *newinode)
266 if (tcon->nocase)
267 direntry->d_op = &cifs_ci_dentry_ops;
268 else
269 direntry->d_op = &cifs_dentry_ops;
270 d_instantiate(direntry, newinode);
273 /* Inode operations in similar order to how they appear in Linux file fs.h */
276 cifs_create(struct inode *inode, struct dentry *direntry, int mode,
277 struct nameidata *nd)
279 int rc = -ENOENT;
280 int xid;
281 int create_options = CREATE_NOT_DIR;
282 __u32 oplock = 0;
283 int oflags;
284 bool posix_create = false;
286 * BB below access is probably too much for mknod to request
287 * but we have to do query and setpathinfo so requesting
288 * less could fail (unless we want to request getatr and setatr
289 * permissions (only). At least for POSIX we do not have to
290 * request so much.
292 int desiredAccess = GENERIC_READ | GENERIC_WRITE;
293 __u16 fileHandle;
294 struct cifs_sb_info *cifs_sb;
295 struct cifsTconInfo *tcon;
296 char *full_path = NULL;
297 FILE_ALL_INFO *buf = NULL;
298 struct inode *newinode = NULL;
299 int disposition = FILE_OVERWRITE_IF;
301 xid = GetXid();
303 cifs_sb = CIFS_SB(inode->i_sb);
304 tcon = cifs_sb->tcon;
306 full_path = build_path_from_dentry(direntry);
307 if (full_path == NULL) {
308 rc = -ENOMEM;
309 FreeXid(xid);
310 return rc;
313 if (oplockEnabled)
314 oplock = REQ_OPLOCK;
316 if (nd && (nd->flags & LOOKUP_OPEN))
317 oflags = nd->intent.open.flags;
318 else
319 oflags = FMODE_READ;
321 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
322 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
323 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
324 rc = cifs_posix_open(full_path, &newinode, nd->path.mnt,
325 mode, oflags, &oplock, &fileHandle, xid);
326 /* EIO could indicate that (posix open) operation is not
327 supported, despite what server claimed in capability
328 negotation. EREMOTE indicates DFS junction, which is not
329 handled in posix open */
331 if (rc == 0) {
332 posix_create = true;
333 if (newinode == NULL) /* query inode info */
334 goto cifs_create_get_file_info;
335 else /* success, no need to query */
336 goto cifs_create_set_dentry;
337 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
338 (rc != -EOPNOTSUPP) && (rc != -EINVAL))
339 goto cifs_create_out;
340 /* else fallthrough to retry, using older open call, this is
341 case where server does not support this SMB level, and
342 falsely claims capability (also get here for DFS case
343 which should be rare for path not covered on files) */
346 if (nd && (nd->flags & LOOKUP_OPEN)) {
347 /* if the file is going to stay open, then we
348 need to set the desired access properly */
349 desiredAccess = 0;
350 if (oflags & FMODE_READ)
351 desiredAccess |= GENERIC_READ; /* is this too little? */
352 if (oflags & FMODE_WRITE)
353 desiredAccess |= GENERIC_WRITE;
355 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
356 disposition = FILE_CREATE;
357 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
358 disposition = FILE_OVERWRITE_IF;
359 else if ((oflags & O_CREAT) == O_CREAT)
360 disposition = FILE_OPEN_IF;
361 else
362 cFYI(1, ("Create flag not set in create function"));
365 /* BB add processing to set equivalent of mode - e.g. via CreateX with
366 ACLs */
368 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
369 if (buf == NULL) {
370 kfree(full_path);
371 FreeXid(xid);
372 return -ENOMEM;
376 * if we're not using unix extensions, see if we need to set
377 * ATTR_READONLY on the create call
379 if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
380 create_options |= CREATE_OPTION_READONLY;
382 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
383 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
384 desiredAccess, create_options,
385 &fileHandle, &oplock, buf, cifs_sb->local_nls,
386 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
387 else
388 rc = -EIO; /* no NT SMB support fall into legacy open below */
390 if (rc == -EIO) {
391 /* old server, retry the open legacy style */
392 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
393 desiredAccess, create_options,
394 &fileHandle, &oplock, buf, cifs_sb->local_nls,
395 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
397 if (rc) {
398 cFYI(1, ("cifs_create returned 0x%x", rc));
399 goto cifs_create_out;
402 /* If Open reported that we actually created a file
403 then we now have to set the mode if possible */
404 if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
405 struct cifs_unix_set_info_args args = {
406 .mode = mode,
407 .ctime = NO_CHANGE_64,
408 .atime = NO_CHANGE_64,
409 .mtime = NO_CHANGE_64,
410 .device = 0,
413 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
414 args.uid = (__u64) current_fsuid();
415 if (inode->i_mode & S_ISGID)
416 args.gid = (__u64) inode->i_gid;
417 else
418 args.gid = (__u64) current_fsgid();
419 } else {
420 args.uid = NO_CHANGE_64;
421 args.gid = NO_CHANGE_64;
423 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
424 cifs_sb->local_nls,
425 cifs_sb->mnt_cifs_flags &
426 CIFS_MOUNT_MAP_SPECIAL_CHR);
427 } else {
428 /* BB implement mode setting via Windows security
429 descriptors e.g. */
430 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
432 /* Could set r/o dos attribute if mode & 0222 == 0 */
435 cifs_create_get_file_info:
436 /* server might mask mode so we have to query for it */
437 if (tcon->unix_ext)
438 rc = cifs_get_inode_info_unix(&newinode, full_path,
439 inode->i_sb, xid);
440 else {
441 rc = cifs_get_inode_info(&newinode, full_path, buf,
442 inode->i_sb, xid, &fileHandle);
443 if (newinode) {
444 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
445 newinode->i_mode = mode;
446 if ((oplock & CIFS_CREATE_ACTION) &&
447 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
448 newinode->i_uid = current_fsuid();
449 if (inode->i_mode & S_ISGID)
450 newinode->i_gid = inode->i_gid;
451 else
452 newinode->i_gid = current_fsgid();
457 cifs_create_set_dentry:
458 if (rc == 0)
459 setup_cifs_dentry(tcon, direntry, newinode);
460 else
461 cFYI(1, ("Create worked, get_inode_info failed rc = %d", rc));
463 /* nfsd case - nfs srv does not set nd */
464 if ((nd == NULL) || (!(nd->flags & LOOKUP_OPEN))) {
465 /* mknod case - do not leave file open */
466 CIFSSMBClose(xid, tcon, fileHandle);
467 } else if (!(posix_create) && (newinode)) {
468 cifs_new_fileinfo(newinode, fileHandle, NULL,
469 nd->path.mnt, oflags);
471 cifs_create_out:
472 kfree(buf);
473 kfree(full_path);
474 FreeXid(xid);
475 return rc;
478 int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
479 dev_t device_number)
481 int rc = -EPERM;
482 int xid;
483 struct cifs_sb_info *cifs_sb;
484 struct cifsTconInfo *pTcon;
485 char *full_path = NULL;
486 struct inode *newinode = NULL;
488 if (!old_valid_dev(device_number))
489 return -EINVAL;
491 xid = GetXid();
493 cifs_sb = CIFS_SB(inode->i_sb);
494 pTcon = cifs_sb->tcon;
496 full_path = build_path_from_dentry(direntry);
497 if (full_path == NULL)
498 rc = -ENOMEM;
499 else if (pTcon->unix_ext) {
500 struct cifs_unix_set_info_args args = {
501 .mode = mode & ~current_umask(),
502 .ctime = NO_CHANGE_64,
503 .atime = NO_CHANGE_64,
504 .mtime = NO_CHANGE_64,
505 .device = device_number,
507 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
508 args.uid = (__u64) current_fsuid();
509 args.gid = (__u64) current_fsgid();
510 } else {
511 args.uid = NO_CHANGE_64;
512 args.gid = NO_CHANGE_64;
514 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
515 cifs_sb->local_nls,
516 cifs_sb->mnt_cifs_flags &
517 CIFS_MOUNT_MAP_SPECIAL_CHR);
519 if (!rc) {
520 rc = cifs_get_inode_info_unix(&newinode, full_path,
521 inode->i_sb, xid);
522 if (pTcon->nocase)
523 direntry->d_op = &cifs_ci_dentry_ops;
524 else
525 direntry->d_op = &cifs_dentry_ops;
526 if (rc == 0)
527 d_instantiate(direntry, newinode);
529 } else {
530 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
531 int oplock = 0;
532 u16 fileHandle;
533 FILE_ALL_INFO *buf;
535 cFYI(1, ("sfu compat create special file"));
537 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
538 if (buf == NULL) {
539 kfree(full_path);
540 rc = -ENOMEM;
541 FreeXid(xid);
542 return rc;
545 rc = CIFSSMBOpen(xid, pTcon, full_path,
546 FILE_CREATE, /* fail if exists */
547 GENERIC_WRITE /* BB would
548 WRITE_OWNER | WRITE_DAC be better? */,
549 /* Create a file and set the
550 file attribute to SYSTEM */
551 CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,
552 &fileHandle, &oplock, buf,
553 cifs_sb->local_nls,
554 cifs_sb->mnt_cifs_flags &
555 CIFS_MOUNT_MAP_SPECIAL_CHR);
557 /* BB FIXME - add handling for backlevel servers
558 which need legacy open and check for all
559 calls to SMBOpen for fallback to SMBLeagcyOpen */
560 if (!rc) {
561 /* BB Do not bother to decode buf since no
562 local inode yet to put timestamps in,
563 but we can reuse it safely */
564 unsigned int bytes_written;
565 struct win_dev *pdev;
566 pdev = (struct win_dev *)buf;
567 if (S_ISCHR(mode)) {
568 memcpy(pdev->type, "IntxCHR", 8);
569 pdev->major =
570 cpu_to_le64(MAJOR(device_number));
571 pdev->minor =
572 cpu_to_le64(MINOR(device_number));
573 rc = CIFSSMBWrite(xid, pTcon,
574 fileHandle,
575 sizeof(struct win_dev),
576 0, &bytes_written, (char *)pdev,
577 NULL, 0);
578 } else if (S_ISBLK(mode)) {
579 memcpy(pdev->type, "IntxBLK", 8);
580 pdev->major =
581 cpu_to_le64(MAJOR(device_number));
582 pdev->minor =
583 cpu_to_le64(MINOR(device_number));
584 rc = CIFSSMBWrite(xid, pTcon,
585 fileHandle,
586 sizeof(struct win_dev),
587 0, &bytes_written, (char *)pdev,
588 NULL, 0);
589 } /* else if(S_ISFIFO */
590 CIFSSMBClose(xid, pTcon, fileHandle);
591 d_drop(direntry);
593 kfree(buf);
594 /* add code here to set EAs */
598 kfree(full_path);
599 FreeXid(xid);
600 return rc;
603 struct dentry *
604 cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
605 struct nameidata *nd)
607 int xid;
608 int rc = 0; /* to get around spurious gcc warning, set to zero here */
609 __u32 oplock = 0;
610 __u16 fileHandle = 0;
611 bool posix_open = false;
612 struct cifs_sb_info *cifs_sb;
613 struct cifsTconInfo *pTcon;
614 struct inode *newInode = NULL;
615 char *full_path = NULL;
616 struct file *filp;
618 xid = GetXid();
620 cFYI(1, ("parent inode = 0x%p name is: %s and dentry = 0x%p",
621 parent_dir_inode, direntry->d_name.name, direntry));
623 /* check whether path exists */
625 cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
626 pTcon = cifs_sb->tcon;
629 * Don't allow the separator character in a path component.
630 * The VFS will not allow "/", but "\" is allowed by posix.
632 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
633 int i;
634 for (i = 0; i < direntry->d_name.len; i++)
635 if (direntry->d_name.name[i] == '\\') {
636 cFYI(1, ("Invalid file name"));
637 FreeXid(xid);
638 return ERR_PTR(-EINVAL);
643 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
644 * the VFS handle the create.
646 if (nd->flags & LOOKUP_EXCL) {
647 d_instantiate(direntry, NULL);
648 return 0;
651 /* can not grab the rename sem here since it would
652 deadlock in the cases (beginning of sys_rename itself)
653 in which we already have the sb rename sem */
654 full_path = build_path_from_dentry(direntry);
655 if (full_path == NULL) {
656 FreeXid(xid);
657 return ERR_PTR(-ENOMEM);
660 if (direntry->d_inode != NULL) {
661 cFYI(1, ("non-NULL inode in lookup"));
662 } else {
663 cFYI(1, ("NULL inode in lookup"));
665 cFYI(1, ("Full path: %s inode = 0x%p", full_path, direntry->d_inode));
667 /* Posix open is only called (at lookup time) for file create now.
668 * For opens (rather than creates), because we do not know if it
669 * is a file or directory yet, and current Samba no longer allows
670 * us to do posix open on dirs, we could end up wasting an open call
671 * on what turns out to be a dir. For file opens, we wait to call posix
672 * open till cifs_open. It could be added here (lookup) in the future
673 * but the performance tradeoff of the extra network request when EISDIR
674 * or EACCES is returned would have to be weighed against the 50%
675 * reduction in network traffic in the other paths.
677 if (pTcon->unix_ext) {
678 if (!(nd->flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY)) &&
679 (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
680 (nd->intent.open.flags & O_CREAT)) {
681 rc = cifs_posix_open(full_path, &newInode, nd->path.mnt,
682 nd->intent.open.create_mode,
683 nd->intent.open.flags, &oplock,
684 &fileHandle, xid);
686 * The check below works around a bug in POSIX
687 * open in samba versions 3.3.1 and earlier where
688 * open could incorrectly fail with invalid parameter.
689 * If either that or op not supported returned, follow
690 * the normal lookup.
692 if ((rc == 0) || (rc == -ENOENT))
693 posix_open = true;
694 else if ((rc == -EINVAL) || (rc != -EOPNOTSUPP))
695 pTcon->broken_posix_open = true;
697 if (!posix_open)
698 rc = cifs_get_inode_info_unix(&newInode, full_path,
699 parent_dir_inode->i_sb, xid);
700 } else
701 rc = cifs_get_inode_info(&newInode, full_path, NULL,
702 parent_dir_inode->i_sb, xid, NULL);
704 if ((rc == 0) && (newInode != NULL)) {
705 if (pTcon->nocase)
706 direntry->d_op = &cifs_ci_dentry_ops;
707 else
708 direntry->d_op = &cifs_dentry_ops;
709 d_add(direntry, newInode);
710 if (posix_open)
711 filp = lookup_instantiate_filp(nd, direntry, NULL);
712 /* since paths are not looked up by component - the parent
713 directories are presumed to be good here */
714 renew_parental_timestamps(direntry);
716 } else if (rc == -ENOENT) {
717 rc = 0;
718 direntry->d_time = jiffies;
719 if (pTcon->nocase)
720 direntry->d_op = &cifs_ci_dentry_ops;
721 else
722 direntry->d_op = &cifs_dentry_ops;
723 d_add(direntry, NULL);
724 /* if it was once a directory (but how can we tell?) we could do
725 shrink_dcache_parent(direntry); */
726 } else if (rc != -EACCES) {
727 cERROR(1, ("Unexpected lookup error %d", rc));
728 /* We special case check for Access Denied - since that
729 is a common return code */
732 kfree(full_path);
733 FreeXid(xid);
734 return ERR_PTR(rc);
737 static int
738 cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
740 int isValid = 1;
742 if (direntry->d_inode) {
743 if (cifs_revalidate(direntry))
744 return 0;
745 } else {
746 cFYI(1, ("neg dentry 0x%p name = %s",
747 direntry, direntry->d_name.name));
748 if (time_after(jiffies, direntry->d_time + HZ) ||
749 !lookupCacheEnabled) {
750 d_drop(direntry);
751 isValid = 0;
755 return isValid;
758 /* static int cifs_d_delete(struct dentry *direntry)
760 int rc = 0;
762 cFYI(1, ("In cifs d_delete, name = %s", direntry->d_name.name));
764 return rc;
765 } */
767 const struct dentry_operations cifs_dentry_ops = {
768 .d_revalidate = cifs_d_revalidate,
769 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
772 static int cifs_ci_hash(struct dentry *dentry, struct qstr *q)
774 struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
775 unsigned long hash;
776 int i;
778 hash = init_name_hash();
779 for (i = 0; i < q->len; i++)
780 hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
781 hash);
782 q->hash = end_name_hash(hash);
784 return 0;
787 static int cifs_ci_compare(struct dentry *dentry, struct qstr *a,
788 struct qstr *b)
790 struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
792 if ((a->len == b->len) &&
793 (nls_strnicmp(codepage, a->name, b->name, a->len) == 0)) {
795 * To preserve case, don't let an existing negative dentry's
796 * case take precedence. If a is not a negative dentry, this
797 * should have no side effects
799 memcpy((void *)a->name, b->name, a->len);
800 return 0;
802 return 1;
805 const struct dentry_operations cifs_ci_dentry_ops = {
806 .d_revalidate = cifs_d_revalidate,
807 .d_hash = cifs_ci_hash,
808 .d_compare = cifs_ci_compare,