1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
6 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 only,
10 * as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License version 2 for more details (a copy is included
16 * in the LICENSE file that accompanied this code).
18 * You should have received a copy of the GNU General Public License
19 * version 2 along with this program; If not, see
20 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
22 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23 * CA 95054 USA or visit www.sun.com if you need additional information or
29 * Copyright 2008 Sun Microsystems, Inc. All rights reserved
30 * Use is subject to license terms.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
38 #include <linux/sched.h>
39 #include <linux/smp_lock.h>
40 #include <linux/quotaops.h>
42 #define DEBUG_SUBSYSTEM S_LLITE
44 #include <obd_support.h>
45 #include <lustre_lite.h>
46 #include <lustre/lustre_idl.h>
47 #include <lustre_dlm.h>
48 #include <lustre_mdc.h>
49 //#include <lustre_ver.h>
50 //#include <lustre_version.h>
52 #include "llite_internal.h"
54 cfs_spinlock_t ll_lookup_lock = CFS_SPIN_LOCK_UNLOCKED;
56 /* should NOT be called with the dcache lock, see fs/dcache.c */
57 static void ll_release(struct dentry *de)
59 struct ll_dentry_data *lld;
63 if (lld == NULL) { /* NFS copies the de->d_op methods (bug 4655) */
67 #ifndef HAVE_VFS_INTENT_PATCHES
69 ll_intent_release(lld->lld_it);
70 OBD_FREE(lld->lld_it, sizeof(*lld->lld_it));
73 LASSERT(lld->lld_cwd_count == 0);
74 LASSERT(lld->lld_mnt_count == 0);
75 OBD_FREE(de->d_fsdata, sizeof(*lld));
80 /* Compare if two dentries are the same. Don't match if the existing dentry
81 * is marked DCACHE_LUSTRE_INVALID. Returns 1 if different, 0 if the same.
83 * This avoids a race where ll_lookup_it() instantiates a dentry, but we get
84 * an AST before calling d_revalidate_it(). The dentry still exists (marked
85 * INVALID) so d_lookup() matches it, but we have no lock on it (so
86 * lock_match() fails) and we spin around real_lookup(). */
87 int ll_dcompare(struct dentry *parent, struct qstr *d_name, struct qstr *name)
89 struct dentry *dchild;
92 if (d_name->len != name->len)
95 if (memcmp(d_name->name, name->name, name->len))
98 /* XXX: d_name must be in-dentry structure */
99 dchild = container_of(d_name, struct dentry, d_name); /* ugh */
101 CDEBUG(D_DENTRY,"found name %.*s(%p) - flags %d/%x - refc %d\n",
102 name->len, name->name, dchild,
103 d_mountpoint(dchild), dchild->d_flags & DCACHE_LUSTRE_INVALID,
104 atomic_read(&dchild->d_count));
106 /* mountpoint is always valid */
107 if (d_mountpoint(dchild))
110 if (dchild->d_flags & DCACHE_LUSTRE_INVALID)
117 static inline int return_if_equal(struct ldlm_lock *lock, void *data)
119 return LDLM_ITER_STOP;
122 /* find any ldlm lock of the inode in mdc and lov
126 static int find_cbdata(struct inode *inode)
128 struct ll_inode_info *lli = ll_i2info(inode);
129 struct ll_sb_info *sbi = ll_i2sbi(inode);
134 rc = md_find_cbdata(sbi->ll_md_exp, ll_inode2fid(inode),
135 return_if_equal, NULL);
140 rc = obd_find_cbdata(sbi->ll_dt_exp, lli->lli_smd,
141 return_if_equal, NULL);
146 /* should NOT be called with the dcache lock, see fs/dcache.c */
147 static int ll_ddelete(struct dentry *de)
152 CDEBUG(D_DENTRY, "%s dentry %.*s (%p, parent %p, inode %p) %s%s\n",
153 (de->d_flags & DCACHE_LUSTRE_INVALID ? "deleting" : "keeping"),
154 de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
155 d_unhashed(de) ? "" : "hashed,",
156 list_empty(&de->d_subdirs) ? "" : "subdirs");
158 /* if not ldlm lock for this inode, set i_nlink to 0 so that
159 * this inode can be recycled later b=20433 */
160 LASSERT(atomic_read(&de->d_count) == 0);
161 if (de->d_inode && !find_cbdata(de->d_inode))
162 de->d_inode->i_nlink = 0;
164 if (de->d_flags & DCACHE_LUSTRE_INVALID)
170 void ll_set_dd(struct dentry *de)
175 CDEBUG(D_DENTRY, "ldd on dentry %.*s (%p) parent %p inode %p refc %d\n",
176 de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
177 atomic_read(&de->d_count));
179 if (de->d_fsdata == NULL) {
180 struct ll_dentry_data *lld;
183 if (likely(lld != NULL)) {
185 if (likely(de->d_fsdata == NULL))
196 void ll_intent_drop_lock(struct lookup_intent *it)
198 struct lustre_handle *handle;
200 if (it->it_op && it->d.lustre.it_lock_mode) {
201 handle = (struct lustre_handle *)&it->d.lustre.it_lock_handle;
202 CDEBUG(D_DLMTRACE, "releasing lock with cookie "LPX64
203 " from it %p\n", handle->cookie, it);
204 ldlm_lock_decref(handle, it->d.lustre.it_lock_mode);
206 /* bug 494: intent_release may be called multiple times, from
207 * this thread and we don't want to double-decref this lock */
208 it->d.lustre.it_lock_mode = 0;
212 void ll_intent_release(struct lookup_intent *it)
216 CDEBUG(D_INFO, "intent %p released\n", it);
217 ll_intent_drop_lock(it);
218 #ifdef HAVE_VFS_INTENT_PATCHES
220 it->it_op_release = 0;
222 /* We are still holding extra reference on a request, need to free it */
223 if (it_disposition(it, DISP_ENQ_OPEN_REF))
224 ptlrpc_req_finished(it->d.lustre.it_data); /* ll_file_open */
225 if (it_disposition(it, DISP_ENQ_CREATE_REF)) /* create rec */
226 ptlrpc_req_finished(it->d.lustre.it_data);
227 if (it_disposition(it, DISP_ENQ_COMPLETE)) /* saved req from revalidate
229 ptlrpc_req_finished(it->d.lustre.it_data);
231 it->d.lustre.it_disposition = 0;
232 it->d.lustre.it_data = NULL;
236 /* Drop dentry if it is not used already, unhash otherwise.
237 Should be called with dcache lock held!
238 Returns: 1 if dentry was dropped, 0 if unhashed. */
239 int ll_drop_dentry(struct dentry *dentry)
242 if (atomic_read(&dentry->d_count) == 0) {
243 CDEBUG(D_DENTRY, "deleting dentry %.*s (%p) parent %p "
244 "inode %p\n", dentry->d_name.len,
245 dentry->d_name.name, dentry, dentry->d_parent,
249 unlock_dentry(dentry);
250 spin_unlock(&dcache_lock);
251 cfs_spin_unlock(&ll_lookup_lock);
253 cfs_spin_lock(&ll_lookup_lock);
254 spin_lock(&dcache_lock);
257 /* disconected dentry can not be find without lookup, because we
258 * not need his to unhash or mark invalid. */
259 if (dentry->d_flags & DCACHE_DISCONNECTED) {
260 unlock_dentry(dentry);
264 if (!(dentry->d_flags & DCACHE_LUSTRE_INVALID)) {
265 CDEBUG(D_DENTRY, "unhashing dentry %.*s (%p) parent %p "
266 "inode %p refc %d\n", dentry->d_name.len,
267 dentry->d_name.name, dentry, dentry->d_parent,
268 dentry->d_inode, atomic_read(&dentry->d_count));
269 /* actually we don't unhash the dentry, rather just
270 * mark it inaccessible for to __d_lookup(). otherwise
271 * sys_getcwd() could return -ENOENT -bzzz */
272 dentry->d_flags |= DCACHE_LUSTRE_INVALID;
273 if (!dentry->d_inode || !S_ISDIR(dentry->d_inode->i_mode))
276 unlock_dentry(dentry);
280 void ll_unhash_aliases(struct inode *inode)
282 struct list_head *tmp, *head;
286 CERROR("unexpected NULL inode, tell phil\n");
290 CDEBUG(D_INODE, "marking dentries for ino %lu/%u(%p) invalid\n",
291 inode->i_ino, inode->i_generation, inode);
293 head = &inode->i_dentry;
294 cfs_spin_lock(&ll_lookup_lock);
295 spin_lock(&dcache_lock);
298 while ((tmp = tmp->next) != head) {
299 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
301 CDEBUG(D_DENTRY, "dentry in drop %.*s (%p) parent %p "
302 "inode %p flags %d\n", dentry->d_name.len,
303 dentry->d_name.name, dentry, dentry->d_parent,
304 dentry->d_inode, dentry->d_flags);
306 if (dentry->d_name.len == 1 && dentry->d_name.name[0] == '/') {
307 CERROR("called on root (?) dentry=%p, inode=%p "
308 "ino=%lu\n", dentry, inode, inode->i_ino);
309 lustre_dump_dentry(dentry, 1);
310 libcfs_debug_dumpstack(NULL);
313 if (ll_drop_dentry(dentry))
316 spin_unlock(&dcache_lock);
317 cfs_spin_unlock(&ll_lookup_lock);
322 int ll_revalidate_it_finish(struct ptlrpc_request *request,
323 struct lookup_intent *it,
332 if (it_disposition(it, DISP_LOOKUP_NEG))
335 rc = ll_prep_inode(&de->d_inode, request, NULL);
340 void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry)
343 LASSERT(dentry != NULL);
345 if (it->d.lustre.it_lock_mode && dentry->d_inode != NULL) {
346 struct inode *inode = dentry->d_inode;
347 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
349 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
350 inode, inode->i_ino, inode->i_generation);
351 md_set_lock_data(sbi->ll_md_exp, &it->d.lustre.it_lock_handle,
355 /* drop lookup or getattr locks immediately */
356 if (it->it_op == IT_LOOKUP || it->it_op == IT_GETATTR) {
357 /* on 2.6 there are situation when several lookups and
358 * revalidations may be requested during single operation.
359 * therefore, we don't release intent here -bzzz */
360 ll_intent_drop_lock(it);
364 void ll_frob_intent(struct lookup_intent **itp, struct lookup_intent *deft)
366 struct lookup_intent *it = *itp;
367 #ifdef HAVE_VFS_INTENT_PATCHES
369 LASSERTF(it->it_magic == INTENT_MAGIC,
370 "%p has bad intent magic: %x\n",
375 if (!it || it->it_op == IT_GETXATTR)
378 #ifdef HAVE_VFS_INTENT_PATCHES
379 it->it_op_release = ll_intent_release;
383 int ll_revalidate_it(struct dentry *de, int lookup_flags,
384 struct lookup_intent *it)
386 struct md_op_data *op_data;
387 struct ptlrpc_request *req = NULL;
388 struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
389 struct obd_export *exp;
390 struct inode *parent = de->d_parent->d_inode;
394 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,intent=%s\n", de->d_name.name,
397 if (de->d_inode == NULL) {
398 /* We can only use negative dentries if this is stat or lookup,
399 for opens and stuff we do need to query server. */
400 /* If there is IT_CREAT in intent op set, then we must throw
401 away this negative dentry and actually do the request to
402 kernel to create whatever needs to be created (if possible)*/
403 if (it && (it->it_op & IT_CREAT))
406 if (de->d_flags & DCACHE_LUSTRE_INVALID)
409 rc = ll_have_md_lock(parent, MDS_INODELOCK_UPDATE);
413 /* Never execute intents for mount points.
414 * Attributes will be fixed up in ll_inode_revalidate_it */
415 if (d_mountpoint(de))
416 GOTO(out_sa, rc = 1);
418 /* need to get attributes in case root got changed from other client */
419 if (de == de->d_sb->s_root) {
420 rc = __ll_inode_revalidate_it(de, it, MDS_INODELOCK_LOOKUP);
426 exp = ll_i2mdexp(de->d_inode);
428 OBD_FAIL_TIMEOUT(OBD_FAIL_MDC_REVALIDATE_PAUSE, 5);
429 ll_frob_intent(&it, &lookup_it);
432 if (it->it_op == IT_LOOKUP && !(de->d_flags & DCACHE_LUSTRE_INVALID))
433 GOTO(out_sa, rc = 1);
435 op_data = ll_prep_md_op_data(NULL, parent, de->d_inode,
436 de->d_name.name, de->d_name.len,
437 0, LUSTRE_OPC_ANY, NULL);
439 RETURN(PTR_ERR(op_data));
441 if ((it->it_op == IT_OPEN) && de->d_inode) {
442 struct inode *inode = de->d_inode;
443 struct ll_inode_info *lli = ll_i2info(inode);
444 struct obd_client_handle **och_p;
448 * We used to check for MDS_INODELOCK_OPEN here, but in fact
449 * just having LOOKUP lock is enough to justify inode is the
450 * same. And if inode is the same and we have suitable
451 * openhandle, then there is no point in doing another OPEN RPC
452 * just to throw away newly received openhandle. There are no
453 * security implications too, if file owner or access mode is
454 * change, LOOKUP lock is revoked.
458 if (it->it_flags & FMODE_WRITE) {
459 och_p = &lli->lli_mds_write_och;
460 och_usecount = &lli->lli_open_fd_write_count;
461 } else if (it->it_flags & FMODE_EXEC) {
462 och_p = &lli->lli_mds_exec_och;
463 och_usecount = &lli->lli_open_fd_exec_count;
465 och_p = &lli->lli_mds_read_och;
466 och_usecount = &lli->lli_open_fd_read_count;
468 /* Check for the proper lock. */
469 if (!ll_have_md_lock(inode, MDS_INODELOCK_LOOKUP))
471 cfs_down(&lli->lli_och_sem);
472 if (*och_p) { /* Everything is open already, do nothing */
473 /*(*och_usecount)++; Do not let them steal our open
474 handle from under us */
475 /* XXX The code above was my original idea, but in case
476 we have the handle, but we cannot use it due to later
477 checks (e.g. O_CREAT|O_EXCL flags set), nobody
478 would decrement counter increased here. So we just
479 hope the lock won't be invalidated in between. But
480 if it would be, we'll reopen the open request to
481 MDS later during file open path */
482 cfs_up(&lli->lli_och_sem);
483 ll_finish_md_op_data(op_data);
486 cfs_up(&lli->lli_och_sem);
490 if (it->it_op == IT_GETATTR) {
491 first = ll_statahead_enter(parent, &de, 0);
493 ll_statahead_exit(parent, de, 1);
494 ll_finish_md_op_data(op_data);
500 it->it_create_mode &= ~current->fs->umask;
501 it->it_create_mode |= M_CHECK_STALE;
502 rc = md_intent_lock(exp, op_data, NULL, 0, it,
504 &req, ll_md_blocking_ast, 0);
505 it->it_create_mode &= ~M_CHECK_STALE;
506 ll_finish_md_op_data(op_data);
507 if (it->it_op == IT_GETATTR && !first)
508 /* If there are too many locks on client-side, then some
509 * locks taken by statahead maybe dropped automatically
510 * before the real "revalidate" using them. */
511 ll_statahead_exit(parent, de, req == NULL ? rc : 0);
512 else if (first == -EEXIST)
513 ll_statahead_mark(parent, de);
515 /* If req is NULL, then md_intent_lock only tried to do a lock match;
516 * if all was well, it will return 1 if it found locks, 0 otherwise. */
517 if (req == NULL && rc >= 0) {
525 CDEBUG(D_INFO, "ll_intent_lock: rc %d : it->it_status "
526 "%d\n", rc, it->d.lustre.it_status);
532 rc = ll_revalidate_it_finish(req, it, de);
534 if (rc != -ESTALE && rc != -ENOENT)
535 ll_intent_release(it);
539 if ((it->it_op & IT_OPEN) && de->d_inode &&
540 !S_ISREG(de->d_inode->i_mode) &&
541 !S_ISDIR(de->d_inode->i_mode)) {
542 ll_release_openhandle(de, it);
546 /* unfortunately ll_intent_lock may cause a callback and revoke our
548 cfs_spin_lock(&ll_lookup_lock);
549 spin_lock(&dcache_lock);
553 d_rehash_cond(de, 0);
554 spin_unlock(&dcache_lock);
555 cfs_spin_unlock(&ll_lookup_lock);
558 /* We do not free request as it may be reused during following lookup
559 * (see comment in mdc/mdc_locks.c::mdc_intent_lock()), request will
560 * be freed in ll_lookup_it or in ll_intent_release. But if
561 * request was not completed, we need to free it. (bug 5154, 9903) */
562 if (req != NULL && !it_disposition(it, DISP_ENQ_COMPLETE))
563 ptlrpc_req_finished(req);
565 ll_unhash_aliases(de->d_inode);
566 /* done in ll_unhash_aliases()
567 dentry->d_flags |= DCACHE_LUSTRE_INVALID; */
569 CDEBUG(D_DENTRY, "revalidated dentry %.*s (%p) parent %p "
570 "inode %p refc %d\n", de->d_name.len,
571 de->d_name.name, de, de->d_parent, de->d_inode,
572 atomic_read(&de->d_count));
574 if (de->d_flags & DCACHE_LUSTRE_INVALID) {
576 de->d_flags &= ~DCACHE_LUSTRE_INVALID;
579 ll_lookup_finish_locks(it, de);
585 * This part is here to combat evil-evil race in real_lookup on 2.6
586 * kernels. The race details are: We enter do_lookup() looking for some
587 * name, there is nothing in dcache for this name yet and d_lookup()
588 * returns NULL. We proceed to real_lookup(), and while we do this,
589 * another process does open on the same file we looking up (most simple
590 * reproducer), open succeeds and the dentry is added. Now back to
591 * us. In real_lookup() we do d_lookup() again and suddenly find the
592 * dentry, so we call d_revalidate on it, but there is no lock, so
593 * without this code we would return 0, but unpatched real_lookup just
594 * returns -ENOENT in such a case instead of retrying the lookup. Once
595 * this is dealt with in real_lookup(), all of this ugly mess can go and
596 * we can just check locks in ->d_revalidate without doing any RPCs
600 if (it != &lookup_it) {
601 /* MDS_INODELOCK_UPDATE needed for IT_GETATTR case. */
602 if (it->it_op == IT_GETATTR)
603 lookup_it.it_op = IT_GETATTR;
604 ll_lookup_finish_locks(it, de);
608 /* Do real lookup here. */
609 op_data = ll_prep_md_op_data(NULL, parent, NULL, de->d_name.name,
610 de->d_name.len, 0, (it->it_op & IT_CREAT ?
612 LUSTRE_OPC_ANY), NULL);
614 RETURN(PTR_ERR(op_data));
616 rc = md_intent_lock(exp, op_data, NULL, 0, it, 0, &req,
617 ll_md_blocking_ast, 0);
619 struct mdt_body *mdt_body;
620 struct lu_fid fid = {.f_seq = 0, .f_oid = 0, .f_ver = 0};
621 mdt_body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
624 fid = *ll_inode2fid(de->d_inode);
626 /* see if we got same inode, if not - return error */
627 if (lu_fid_eq(&fid, &mdt_body->fid1)) {
628 ll_finish_md_op_data(op_data);
630 goto revalidate_finish;
632 ll_intent_release(it);
634 ll_finish_md_op_data(op_data);
639 * For rc == 1 case, should not return directly to prevent losing
640 * statahead windows; for rc == 0 case, the "lookup" will be done later.
642 if (it && it->it_op == IT_GETATTR && rc == 1) {
643 first = ll_statahead_enter(parent, &de, 0);
645 ll_statahead_exit(parent, de, 1);
646 else if (first == -EEXIST)
647 ll_statahead_mark(parent, de);
654 static void ll_pin(struct dentry *de, struct vfsmount *mnt, int flag)
656 struct inode *inode= de->d_inode;
657 struct ll_sb_info *sbi = ll_i2sbi(inode);
658 struct ll_dentry_data *ldd = ll_d2d(de);
659 struct obd_client_handle *handle;
666 /* Strictly speaking this introduces an additional race: the
667 * increments should wait until the rpc has returned.
668 * However, given that at present the function is void, this
670 if (flag == 1 && (++ldd->lld_mnt_count) > 1) {
676 if (flag == 0 && (++ldd->lld_cwd_count) > 1) {
683 handle = (flag) ? &ldd->lld_mnt_och : &ldd->lld_cwd_och;
684 oc = ll_mdscapa_get(inode);
685 rc = obd_pin(sbi->ll_md_exp, ll_inode2fid(inode), oc, handle, flag);
689 memset(handle, 0, sizeof(*handle));
691 ldd->lld_cwd_count--;
693 ldd->lld_mnt_count--;
701 static void ll_unpin(struct dentry *de, struct vfsmount *mnt, int flag)
703 struct ll_sb_info *sbi = ll_i2sbi(de->d_inode);
704 struct ll_dentry_data *ldd = ll_d2d(de);
705 struct obd_client_handle handle;
711 /* Strictly speaking this introduces an additional race: the
712 * increments should wait until the rpc has returned.
713 * However, given that at present the function is void, this
715 handle = (flag) ? ldd->lld_mnt_och : ldd->lld_cwd_och;
716 if (handle.och_magic != OBD_CLIENT_HANDLE_MAGIC) {
717 /* the "pin" failed */
724 count = --ldd->lld_mnt_count;
726 count = --ldd->lld_cwd_count;
734 rc = obd_unpin(sbi->ll_md_exp, &handle, flag);
740 #ifdef HAVE_VFS_INTENT_PATCHES
741 int ll_revalidate_nd(struct dentry *dentry, struct nameidata *nd)
746 if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
747 rc = ll_revalidate_it(dentry, nd->flags, &nd->intent);
749 rc = ll_revalidate_it(dentry, 0, NULL);
754 int ll_revalidate_nd(struct dentry *dentry, struct nameidata *nd)
759 if (nd && !(nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT))) {
760 struct lookup_intent *it;
761 it = ll_convert_intent(&nd->intent.open, nd->flags);
764 if (it->it_op == (IT_OPEN|IT_CREAT))
765 if (nd->intent.open.flags & O_EXCL) {
766 CDEBUG(D_VFSTRACE, "create O_EXCL, returning 0\n");
771 rc = ll_revalidate_it(dentry, nd->flags, it);
773 if (rc && (nd->flags & LOOKUP_OPEN) &&
774 it_disposition(it, DISP_OPEN_OPEN)) {/*Open*/
775 #ifdef HAVE_FILE_IN_STRUCT_INTENT
776 // XXX Code duplication with ll_lookup_nd
777 if (S_ISFIFO(dentry->d_inode->i_mode)) {
778 // We cannot call open here as it would
781 (struct ptlrpc_request *)
782 it->d.lustre.it_data);
784 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17))
785 /* 2.6.1[456] have a bug in open_namei() that forgets to check
786 * nd->intent.open.file for error, so we need to return it as lookup's result
790 nd->intent.open.file->private_data = it;
791 filp = lookup_instantiate_filp(nd, dentry,NULL);
796 nd->intent.open.file->private_data = it;
797 (void)lookup_instantiate_filp(nd, dentry,NULL);
801 ll_release_openhandle(dentry, it);
802 #endif /* HAVE_FILE_IN_STRUCT_INTENT */
804 if (!rc && (nd->flags & LOOKUP_CREATE) &&
805 it_disposition(it, DISP_OPEN_CREATE)) {
806 /* We created something but we may only return
807 * negative dentry here, so save request in dentry,
808 * if lookup will be called later on, it will
809 * pick the request, otherwise it would be freed
811 ll_d2d(dentry)->lld_it = it;
812 it = NULL; /* avoid freeing */
817 ll_intent_release(it);
818 OBD_FREE(it, sizeof(*it));
821 rc = ll_revalidate_it(dentry, 0, NULL);
828 void ll_d_iput(struct dentry *de, struct inode *inode)
831 if (!find_cbdata(inode))
836 struct dentry_operations ll_d_ops = {
837 .d_revalidate = ll_revalidate_nd,
838 .d_release = ll_release,
839 .d_delete = ll_ddelete,
841 .d_compare = ll_dcompare,