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 (c) 2002, 2010, Oracle and/or its affiliates. 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 if (lock->l_flags & LDLM_FL_CANCELING)
120 return LDLM_ITER_CONTINUE;
121 return LDLM_ITER_STOP;
124 /* find any ldlm lock of the inode in mdc and lov
128 static int find_cbdata(struct inode *inode)
130 struct ll_inode_info *lli = ll_i2info(inode);
131 struct ll_sb_info *sbi = ll_i2sbi(inode);
136 rc = md_find_cbdata(sbi->ll_md_exp, ll_inode2fid(inode),
137 return_if_equal, NULL);
142 rc = obd_find_cbdata(sbi->ll_dt_exp, lli->lli_smd,
143 return_if_equal, NULL);
148 /* should NOT be called with the dcache lock, see fs/dcache.c */
149 static int ll_ddelete(struct dentry *de)
154 CDEBUG(D_DENTRY, "%s dentry %.*s (%p, parent %p, inode %p) %s%s\n",
155 (de->d_flags & DCACHE_LUSTRE_INVALID ? "deleting" : "keeping"),
156 de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
157 d_unhashed(de) ? "" : "hashed,",
158 list_empty(&de->d_subdirs) ? "" : "subdirs");
160 /* if not ldlm lock for this inode, set i_nlink to 0 so that
161 * this inode can be recycled later b=20433 */
162 LASSERT(atomic_read(&de->d_count) == 0);
163 if (de->d_inode && !find_cbdata(de->d_inode))
164 de->d_inode->i_nlink = 0;
166 if (de->d_flags & DCACHE_LUSTRE_INVALID)
172 int ll_set_dd(struct dentry *de)
177 CDEBUG(D_DENTRY, "ldd on dentry %.*s (%p) parent %p inode %p refc %d\n",
178 de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
179 atomic_read(&de->d_count));
181 if (de->d_fsdata == NULL) {
182 struct ll_dentry_data *lld;
185 if (likely(lld != NULL)) {
186 CFS_INIT_LIST_HEAD(&lld->lld_sa_alias);
188 if (likely(de->d_fsdata == NULL))
201 void ll_intent_drop_lock(struct lookup_intent *it)
203 struct lustre_handle *handle;
205 if (it->it_op && it->d.lustre.it_lock_mode) {
206 handle = (struct lustre_handle *)&it->d.lustre.it_lock_handle;
207 CDEBUG(D_DLMTRACE, "releasing lock with cookie "LPX64
208 " from it %p\n", handle->cookie, it);
209 ldlm_lock_decref(handle, it->d.lustre.it_lock_mode);
211 /* bug 494: intent_release may be called multiple times, from
212 * this thread and we don't want to double-decref this lock */
213 it->d.lustre.it_lock_mode = 0;
217 void ll_intent_release(struct lookup_intent *it)
221 CDEBUG(D_INFO, "intent %p released\n", it);
222 ll_intent_drop_lock(it);
223 #ifdef HAVE_VFS_INTENT_PATCHES
225 it->it_op_release = 0;
227 /* We are still holding extra reference on a request, need to free it */
228 if (it_disposition(it, DISP_ENQ_OPEN_REF))
229 ptlrpc_req_finished(it->d.lustre.it_data); /* ll_file_open */
230 if (it_disposition(it, DISP_ENQ_CREATE_REF)) /* create rec */
231 ptlrpc_req_finished(it->d.lustre.it_data);
232 if (it_disposition(it, DISP_ENQ_COMPLETE)) /* saved req from revalidate
234 ptlrpc_req_finished(it->d.lustre.it_data);
236 it->d.lustre.it_disposition = 0;
237 it->d.lustre.it_data = NULL;
241 /* Drop dentry if it is not used already, unhash otherwise.
242 Should be called with dcache lock held!
243 Returns: 1 if dentry was dropped, 0 if unhashed. */
244 int ll_drop_dentry(struct dentry *dentry)
247 if (atomic_read(&dentry->d_count) == 0) {
248 CDEBUG(D_DENTRY, "deleting dentry %.*s (%p) parent %p "
249 "inode %p\n", dentry->d_name.len,
250 dentry->d_name.name, dentry, dentry->d_parent,
254 unlock_dentry(dentry);
255 spin_unlock(&dcache_lock);
256 cfs_spin_unlock(&ll_lookup_lock);
258 cfs_spin_lock(&ll_lookup_lock);
259 spin_lock(&dcache_lock);
262 /* disconected dentry can not be find without lookup, because we
263 * not need his to unhash or mark invalid. */
264 if (dentry->d_flags & DCACHE_DISCONNECTED) {
265 unlock_dentry(dentry);
269 if (!(dentry->d_flags & DCACHE_LUSTRE_INVALID)) {
270 CDEBUG(D_DENTRY, "unhashing dentry %.*s (%p) parent %p "
271 "inode %p refc %d\n", dentry->d_name.len,
272 dentry->d_name.name, dentry, dentry->d_parent,
273 dentry->d_inode, atomic_read(&dentry->d_count));
274 /* actually we don't unhash the dentry, rather just
275 * mark it inaccessible for to __d_lookup(). otherwise
276 * sys_getcwd() could return -ENOENT -bzzz */
277 dentry->d_flags |= DCACHE_LUSTRE_INVALID;
278 if (!dentry->d_inode || !S_ISDIR(dentry->d_inode->i_mode))
281 unlock_dentry(dentry);
285 void ll_unhash_aliases(struct inode *inode)
287 struct list_head *tmp, *head;
291 CERROR("unexpected NULL inode, tell phil\n");
295 CDEBUG(D_INODE, "marking dentries for ino %lu/%u(%p) invalid\n",
296 inode->i_ino, inode->i_generation, inode);
298 head = &inode->i_dentry;
299 cfs_spin_lock(&ll_lookup_lock);
300 spin_lock(&dcache_lock);
303 while ((tmp = tmp->next) != head) {
304 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
306 CDEBUG(D_DENTRY, "dentry in drop %.*s (%p) parent %p "
307 "inode %p flags %d\n", dentry->d_name.len,
308 dentry->d_name.name, dentry, dentry->d_parent,
309 dentry->d_inode, dentry->d_flags);
311 if (dentry->d_name.len == 1 && dentry->d_name.name[0] == '/') {
312 CERROR("called on root (?) dentry=%p, inode=%p "
313 "ino=%lu\n", dentry, inode, inode->i_ino);
314 lustre_dump_dentry(dentry, 1);
315 libcfs_debug_dumpstack(NULL);
318 if (ll_drop_dentry(dentry))
321 spin_unlock(&dcache_lock);
322 cfs_spin_unlock(&ll_lookup_lock);
327 int ll_revalidate_it_finish(struct ptlrpc_request *request,
328 struct lookup_intent *it,
337 if (it_disposition(it, DISP_LOOKUP_NEG))
340 rc = ll_prep_inode(&de->d_inode, request, NULL);
345 void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry)
348 LASSERT(dentry != NULL);
350 if (it->d.lustre.it_lock_mode && dentry->d_inode != NULL) {
351 struct inode *inode = dentry->d_inode;
352 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
354 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
355 inode, inode->i_ino, inode->i_generation);
356 md_set_lock_data(sbi->ll_md_exp, &it->d.lustre.it_lock_handle,
360 /* drop lookup or getattr locks immediately */
361 if (it->it_op == IT_LOOKUP || it->it_op == IT_GETATTR) {
362 /* on 2.6 there are situation when several lookups and
363 * revalidations may be requested during single operation.
364 * therefore, we don't release intent here -bzzz */
365 ll_intent_drop_lock(it);
369 void ll_frob_intent(struct lookup_intent **itp, struct lookup_intent *deft)
371 struct lookup_intent *it = *itp;
372 #ifdef HAVE_VFS_INTENT_PATCHES
374 LASSERTF(it->it_magic == INTENT_MAGIC,
375 "%p has bad intent magic: %x\n",
380 if (!it || it->it_op == IT_GETXATTR)
383 #ifdef HAVE_VFS_INTENT_PATCHES
384 it->it_op_release = ll_intent_release;
388 int ll_revalidate_it(struct dentry *de, int lookup_flags,
389 struct lookup_intent *it)
391 struct md_op_data *op_data;
392 struct ptlrpc_request *req = NULL;
393 struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
394 struct obd_export *exp;
395 struct inode *parent = de->d_parent->d_inode;
399 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,intent=%s\n", de->d_name.name,
402 if (de->d_inode == NULL) {
403 /* We can only use negative dentries if this is stat or lookup,
404 for opens and stuff we do need to query server. */
405 /* If there is IT_CREAT in intent op set, then we must throw
406 away this negative dentry and actually do the request to
407 kernel to create whatever needs to be created (if possible)*/
408 if (it && (it->it_op & IT_CREAT))
411 if (de->d_flags & DCACHE_LUSTRE_INVALID)
414 rc = ll_have_md_lock(parent, MDS_INODELOCK_UPDATE, LCK_MINMODE);
418 /* Never execute intents for mount points.
419 * Attributes will be fixed up in ll_inode_revalidate_it */
420 if (d_mountpoint(de))
421 GOTO(out_sa, rc = 1);
423 /* need to get attributes in case root got changed from other client */
424 if (de == de->d_sb->s_root) {
425 rc = __ll_inode_revalidate_it(de, it, MDS_INODELOCK_LOOKUP);
431 exp = ll_i2mdexp(de->d_inode);
433 OBD_FAIL_TIMEOUT(OBD_FAIL_MDC_REVALIDATE_PAUSE, 5);
434 ll_frob_intent(&it, &lookup_it);
437 if (it->it_op == IT_LOOKUP && !(de->d_flags & DCACHE_LUSTRE_INVALID))
438 GOTO(out_sa, rc = 1);
440 op_data = ll_prep_md_op_data(NULL, parent, de->d_inode,
441 de->d_name.name, de->d_name.len,
442 0, LUSTRE_OPC_ANY, NULL);
444 RETURN(PTR_ERR(op_data));
446 if ((it->it_op == IT_OPEN) && de->d_inode) {
447 struct inode *inode = de->d_inode;
448 struct ll_inode_info *lli = ll_i2info(inode);
449 struct obd_client_handle **och_p;
453 * We used to check for MDS_INODELOCK_OPEN here, but in fact
454 * just having LOOKUP lock is enough to justify inode is the
455 * same. And if inode is the same and we have suitable
456 * openhandle, then there is no point in doing another OPEN RPC
457 * just to throw away newly received openhandle. There are no
458 * security implications too, if file owner or access mode is
459 * change, LOOKUP lock is revoked.
463 if (it->it_flags & FMODE_WRITE) {
464 och_p = &lli->lli_mds_write_och;
465 och_usecount = &lli->lli_open_fd_write_count;
466 } else if (it->it_flags & FMODE_EXEC) {
467 och_p = &lli->lli_mds_exec_och;
468 och_usecount = &lli->lli_open_fd_exec_count;
470 och_p = &lli->lli_mds_read_och;
471 och_usecount = &lli->lli_open_fd_read_count;
473 /* Check for the proper lock. */
474 if (!ll_have_md_lock(inode, MDS_INODELOCK_LOOKUP, LCK_MINMODE))
476 cfs_down(&lli->lli_och_sem);
477 if (*och_p) { /* Everything is open already, do nothing */
478 /*(*och_usecount)++; Do not let them steal our open
479 handle from under us */
480 /* XXX The code above was my original idea, but in case
481 we have the handle, but we cannot use it due to later
482 checks (e.g. O_CREAT|O_EXCL flags set), nobody
483 would decrement counter increased here. So we just
484 hope the lock won't be invalidated in between. But
485 if it would be, we'll reopen the open request to
486 MDS later during file open path */
487 cfs_up(&lli->lli_och_sem);
488 ll_finish_md_op_data(op_data);
491 cfs_up(&lli->lli_och_sem);
495 if (it->it_op == IT_GETATTR) {
496 first = ll_statahead_enter(parent, &de, 0);
498 ll_statahead_exit(parent, de, 1);
499 ll_finish_md_op_data(op_data);
505 it->it_create_mode &= ~current->fs->umask;
506 it->it_create_mode |= M_CHECK_STALE;
507 rc = md_intent_lock(exp, op_data, NULL, 0, it,
509 &req, ll_md_blocking_ast, 0);
510 it->it_create_mode &= ~M_CHECK_STALE;
511 ll_finish_md_op_data(op_data);
512 if (it->it_op == IT_GETATTR && !first)
513 /* If there are too many locks on client-side, then some
514 * locks taken by statahead maybe dropped automatically
515 * before the real "revalidate" using them. */
516 ll_statahead_exit(parent, de, req == NULL ? rc : 0);
517 else if (first == -EEXIST)
518 ll_statahead_mark(parent, de);
520 /* If req is NULL, then md_intent_lock only tried to do a lock match;
521 * if all was well, it will return 1 if it found locks, 0 otherwise. */
522 if (req == NULL && rc >= 0) {
530 CDEBUG(D_INFO, "ll_intent_lock: rc %d : it->it_status "
531 "%d\n", rc, it->d.lustre.it_status);
537 rc = ll_revalidate_it_finish(req, it, de);
539 if (rc != -ESTALE && rc != -ENOENT)
540 ll_intent_release(it);
544 if ((it->it_op & IT_OPEN) && de->d_inode &&
545 !S_ISREG(de->d_inode->i_mode) &&
546 !S_ISDIR(de->d_inode->i_mode)) {
547 ll_release_openhandle(de, it);
551 /* unfortunately ll_intent_lock may cause a callback and revoke our
553 cfs_spin_lock(&ll_lookup_lock);
554 spin_lock(&dcache_lock);
558 d_rehash_cond(de, 0);
559 spin_unlock(&dcache_lock);
560 cfs_spin_unlock(&ll_lookup_lock);
563 /* We do not free request as it may be reused during following lookup
564 * (see comment in mdc/mdc_locks.c::mdc_intent_lock()), request will
565 * be freed in ll_lookup_it or in ll_intent_release. But if
566 * request was not completed, we need to free it. (bug 5154, 9903) */
567 if (req != NULL && !it_disposition(it, DISP_ENQ_COMPLETE))
568 ptlrpc_req_finished(req);
570 ll_unhash_aliases(de->d_inode);
571 /* done in ll_unhash_aliases()
572 dentry->d_flags |= DCACHE_LUSTRE_INVALID; */
574 CDEBUG(D_DENTRY, "revalidated dentry %.*s (%p) parent %p "
575 "inode %p refc %d\n", de->d_name.len,
576 de->d_name.name, de, de->d_parent, de->d_inode,
577 atomic_read(&de->d_count));
579 if (de->d_flags & DCACHE_LUSTRE_INVALID) {
581 de->d_flags &= ~DCACHE_LUSTRE_INVALID;
584 ll_lookup_finish_locks(it, de);
590 * This part is here to combat evil-evil race in real_lookup on 2.6
591 * kernels. The race details are: We enter do_lookup() looking for some
592 * name, there is nothing in dcache for this name yet and d_lookup()
593 * returns NULL. We proceed to real_lookup(), and while we do this,
594 * another process does open on the same file we looking up (most simple
595 * reproducer), open succeeds and the dentry is added. Now back to
596 * us. In real_lookup() we do d_lookup() again and suddenly find the
597 * dentry, so we call d_revalidate on it, but there is no lock, so
598 * without this code we would return 0, but unpatched real_lookup just
599 * returns -ENOENT in such a case instead of retrying the lookup. Once
600 * this is dealt with in real_lookup(), all of this ugly mess can go and
601 * we can just check locks in ->d_revalidate without doing any RPCs
605 if (it != &lookup_it) {
606 /* MDS_INODELOCK_UPDATE needed for IT_GETATTR case. */
607 if (it->it_op == IT_GETATTR)
608 lookup_it.it_op = IT_GETATTR;
609 ll_lookup_finish_locks(it, de);
613 /* Do real lookup here. */
614 op_data = ll_prep_md_op_data(NULL, parent, NULL, de->d_name.name,
615 de->d_name.len, 0, (it->it_op & IT_CREAT ?
617 LUSTRE_OPC_ANY), NULL);
619 RETURN(PTR_ERR(op_data));
621 rc = md_intent_lock(exp, op_data, NULL, 0, it, 0, &req,
622 ll_md_blocking_ast, 0);
624 struct mdt_body *mdt_body;
625 struct lu_fid fid = {.f_seq = 0, .f_oid = 0, .f_ver = 0};
626 mdt_body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
629 fid = *ll_inode2fid(de->d_inode);
631 /* see if we got same inode, if not - return error */
632 if (lu_fid_eq(&fid, &mdt_body->fid1)) {
633 ll_finish_md_op_data(op_data);
635 goto revalidate_finish;
637 ll_intent_release(it);
639 ll_finish_md_op_data(op_data);
644 * For rc == 1 case, should not return directly to prevent losing
645 * statahead windows; for rc == 0 case, the "lookup" will be done later.
647 if (it && it->it_op == IT_GETATTR && rc == 1) {
648 first = ll_statahead_enter(parent, &de, 0);
650 ll_statahead_exit(parent, de, 1);
651 else if (first == -EEXIST)
652 ll_statahead_mark(parent, de);
659 static void ll_pin(struct dentry *de, struct vfsmount *mnt, int flag)
661 struct inode *inode= de->d_inode;
662 struct ll_sb_info *sbi = ll_i2sbi(inode);
663 struct ll_dentry_data *ldd = ll_d2d(de);
664 struct obd_client_handle *handle;
671 /* Strictly speaking this introduces an additional race: the
672 * increments should wait until the rpc has returned.
673 * However, given that at present the function is void, this
675 if (flag == 1 && (++ldd->lld_mnt_count) > 1) {
681 if (flag == 0 && (++ldd->lld_cwd_count) > 1) {
688 handle = (flag) ? &ldd->lld_mnt_och : &ldd->lld_cwd_och;
689 oc = ll_mdscapa_get(inode);
690 rc = obd_pin(sbi->ll_md_exp, ll_inode2fid(inode), oc, handle, flag);
694 memset(handle, 0, sizeof(*handle));
696 ldd->lld_cwd_count--;
698 ldd->lld_mnt_count--;
706 static void ll_unpin(struct dentry *de, struct vfsmount *mnt, int flag)
708 struct ll_sb_info *sbi = ll_i2sbi(de->d_inode);
709 struct ll_dentry_data *ldd = ll_d2d(de);
710 struct obd_client_handle handle;
716 /* Strictly speaking this introduces an additional race: the
717 * increments should wait until the rpc has returned.
718 * However, given that at present the function is void, this
720 handle = (flag) ? ldd->lld_mnt_och : ldd->lld_cwd_och;
721 if (handle.och_magic != OBD_CLIENT_HANDLE_MAGIC) {
722 /* the "pin" failed */
729 count = --ldd->lld_mnt_count;
731 count = --ldd->lld_cwd_count;
739 rc = obd_unpin(sbi->ll_md_exp, &handle, flag);
745 #ifdef HAVE_VFS_INTENT_PATCHES
746 int ll_revalidate_nd(struct dentry *dentry, struct nameidata *nd)
751 if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
752 rc = ll_revalidate_it(dentry, nd->flags, &nd->intent);
754 rc = ll_revalidate_it(dentry, 0, NULL);
759 int ll_revalidate_nd(struct dentry *dentry, struct nameidata *nd)
764 if (nd && !(nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT))) {
765 struct lookup_intent *it;
766 it = ll_convert_intent(&nd->intent.open, nd->flags);
769 if (it->it_op == (IT_OPEN|IT_CREAT))
770 if (nd->intent.open.flags & O_EXCL) {
771 CDEBUG(D_VFSTRACE, "create O_EXCL, returning 0\n");
776 rc = ll_revalidate_it(dentry, nd->flags, it);
778 if (rc && (nd->flags & LOOKUP_OPEN) &&
779 it_disposition(it, DISP_OPEN_OPEN)) {/*Open*/
780 #ifdef HAVE_FILE_IN_STRUCT_INTENT
781 // XXX Code duplication with ll_lookup_nd
782 if (S_ISFIFO(dentry->d_inode->i_mode)) {
783 // We cannot call open here as it would
786 (struct ptlrpc_request *)
787 it->d.lustre.it_data);
789 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17))
790 /* 2.6.1[456] have a bug in open_namei() that forgets to check
791 * nd->intent.open.file for error, so we need to return it as lookup's result
795 nd->intent.open.file->private_data = it;
796 filp = lookup_instantiate_filp(nd, dentry,NULL);
801 nd->intent.open.file->private_data = it;
802 (void)lookup_instantiate_filp(nd, dentry,NULL);
806 ll_release_openhandle(dentry, it);
807 #endif /* HAVE_FILE_IN_STRUCT_INTENT */
809 if (!rc && (nd->flags & LOOKUP_CREATE) &&
810 it_disposition(it, DISP_OPEN_CREATE)) {
811 /* We created something but we may only return
812 * negative dentry here, so save request in dentry,
813 * if lookup will be called later on, it will
814 * pick the request, otherwise it would be freed
816 ll_d2d(dentry)->lld_it = it;
817 it = NULL; /* avoid freeing */
822 ll_intent_release(it);
823 OBD_FREE(it, sizeof(*it));
826 rc = ll_revalidate_it(dentry, 0, NULL);
833 void ll_d_iput(struct dentry *de, struct inode *inode)
836 if (!find_cbdata(inode))
841 struct dentry_operations ll_d_ops = {
842 .d_revalidate = ll_revalidate_nd,
843 .d_release = ll_release,
844 .d_delete = ll_ddelete,
846 .d_compare = ll_dcompare,