4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
27 * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2011, 2015, Intel Corporation.
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/quotaops.h>
41 #define DEBUG_SUBSYSTEM S_LLITE
43 #include "../include/obd_support.h"
44 #include "../include/lustre_lite.h"
45 #include "../include/lustre/lustre_idl.h"
46 #include "../include/lustre_dlm.h"
48 #include "llite_internal.h"
50 static void free_dentry_data(struct rcu_head
*head
)
52 struct ll_dentry_data
*lld
;
54 lld
= container_of(head
, struct ll_dentry_data
, lld_rcu_head
);
58 /* should NOT be called with the dcache lock, see fs/dcache.c */
59 static void ll_release(struct dentry
*de
)
61 struct ll_dentry_data
*lld
;
65 if (!lld
) /* NFS copies the de->d_op methods (bug 4655) */
69 ll_intent_release(lld
->lld_it
);
74 call_rcu(&lld
->lld_rcu_head
, free_dentry_data
);
77 /* Compare if two dentries are the same. Don't match if the existing dentry
78 * is marked invalid. Returns 1 if different, 0 if the same.
80 * This avoids a race where ll_lookup_it() instantiates a dentry, but we get
81 * an AST before calling d_revalidate_it(). The dentry still exists (marked
82 * INVALID) so d_lookup() matches it, but we have no lock on it (so
83 * lock_match() fails) and we spin around real_lookup(). */
84 static int ll_dcompare(const struct dentry
*parent
, const struct dentry
*dentry
,
85 unsigned int len
, const char *str
,
86 const struct qstr
*name
)
91 if (memcmp(str
, name
->name
, len
))
94 CDEBUG(D_DENTRY
, "found name %.*s(%p) flags %#x refc %d\n",
95 name
->len
, name
->name
, dentry
, dentry
->d_flags
,
98 /* mountpoint is always valid */
99 if (d_mountpoint((struct dentry
*)dentry
))
102 if (d_lustre_invalid(dentry
))
108 static inline int return_if_equal(struct ldlm_lock
*lock
, void *data
)
111 (LDLM_FL_CANCELING
| LDLM_FL_DISCARD_DATA
)) ==
112 (LDLM_FL_CANCELING
| LDLM_FL_DISCARD_DATA
))
113 return LDLM_ITER_CONTINUE
;
114 return LDLM_ITER_STOP
;
117 /* find any ldlm lock of the inode in mdc and lov
121 static int find_cbdata(struct inode
*inode
)
123 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
124 struct lov_stripe_md
*lsm
;
128 rc
= md_find_cbdata(sbi
->ll_md_exp
, ll_inode2fid(inode
),
129 return_if_equal
, NULL
);
133 lsm
= ccc_inode_lsm_get(inode
);
137 rc
= obd_find_cbdata(sbi
->ll_dt_exp
, lsm
, return_if_equal
, NULL
);
138 ccc_inode_lsm_put(inode
, lsm
);
144 * Called when last reference to a dentry is dropped and dcache wants to know
145 * whether or not it should cache it:
146 * - return 1 to delete the dentry immediately
147 * - return 0 to cache the dentry
148 * Should NOT be called with the dcache lock, see fs/dcache.c
150 static int ll_ddelete(const struct dentry
*de
)
154 CDEBUG(D_DENTRY
, "%s dentry %pd (%p, parent %p, inode %p) %s%s\n",
155 d_lustre_invalid((struct dentry
*)de
) ? "deleting" : "keeping",
156 de
, de
, de
->d_parent
, d_inode(de
),
157 d_unhashed(de
) ? "" : "hashed,",
158 list_empty(&de
->d_subdirs
) ? "" : "subdirs");
160 /* kernel >= 2.6.38 last refcount is decreased after this function. */
161 LASSERT(d_count(de
) == 1);
163 /* Disable this piece of code temporarily because this is called
164 * inside dcache_lock so it's not appropriate to do lots of work
165 * here. ATTENTION: Before this piece of code enabling, LU-2487 must be
168 /* if not ldlm lock for this inode, set i_nlink to 0 so that
169 * this inode can be recycled later b=20433 */
170 if (d_really_is_positive(de
) && !find_cbdata(d_inode(de
)))
171 clear_nlink(d_inode(de
));
174 if (d_lustre_invalid((struct dentry
*)de
))
179 int ll_d_init(struct dentry
*de
)
183 CDEBUG(D_DENTRY
, "ldd on dentry %pd (%p) parent %p inode %p refc %d\n",
184 de
, de
, de
->d_parent
, d_inode(de
),
188 struct ll_dentry_data
*lld
;
190 lld
= kzalloc(sizeof(*lld
), GFP_NOFS
);
192 spin_lock(&de
->d_lock
);
193 if (likely(!de
->d_fsdata
)) {
195 __d_lustre_invalidate(de
);
199 spin_unlock(&de
->d_lock
);
204 LASSERT(de
->d_op
== &ll_d_ops
);
209 void ll_intent_drop_lock(struct lookup_intent
*it
)
211 if (it
->it_op
&& it
->d
.lustre
.it_lock_mode
) {
212 struct lustre_handle handle
;
214 handle
.cookie
= it
->d
.lustre
.it_lock_handle
;
216 CDEBUG(D_DLMTRACE
, "releasing lock with cookie %#llx from it %p\n",
218 ldlm_lock_decref(&handle
, it
->d
.lustre
.it_lock_mode
);
220 /* bug 494: intent_release may be called multiple times, from
221 * this thread and we don't want to double-decref this lock */
222 it
->d
.lustre
.it_lock_mode
= 0;
223 if (it
->d
.lustre
.it_remote_lock_mode
!= 0) {
224 handle
.cookie
= it
->d
.lustre
.it_remote_lock_handle
;
226 CDEBUG(D_DLMTRACE
, "releasing remote lock with cookie%#llx from it %p\n",
228 ldlm_lock_decref(&handle
,
229 it
->d
.lustre
.it_remote_lock_mode
);
230 it
->d
.lustre
.it_remote_lock_mode
= 0;
235 void ll_intent_release(struct lookup_intent
*it
)
237 CDEBUG(D_INFO
, "intent %p released\n", it
);
238 ll_intent_drop_lock(it
);
239 /* We are still holding extra reference on a request, need to free it */
240 if (it_disposition(it
, DISP_ENQ_OPEN_REF
))
241 ptlrpc_req_finished(it
->d
.lustre
.it_data
); /* ll_file_open */
243 if (it_disposition(it
, DISP_ENQ_CREATE_REF
)) /* create rec */
244 ptlrpc_req_finished(it
->d
.lustre
.it_data
);
246 it
->d
.lustre
.it_disposition
= 0;
247 it
->d
.lustre
.it_data
= NULL
;
250 void ll_invalidate_aliases(struct inode
*inode
)
252 struct dentry
*dentry
;
254 LASSERT(inode
!= NULL
);
256 CDEBUG(D_INODE
, "marking dentries for ino %lu/%u(%p) invalid\n",
257 inode
->i_ino
, inode
->i_generation
, inode
);
259 ll_lock_dcache(inode
);
260 hlist_for_each_entry(dentry
, &inode
->i_dentry
, d_u
.d_alias
) {
261 CDEBUG(D_DENTRY
, "dentry in drop %pd (%p) parent %p inode %p flags %d\n",
262 dentry
, dentry
, dentry
->d_parent
,
263 d_inode(dentry
), dentry
->d_flags
);
265 d_lustre_invalidate(dentry
, 0);
267 ll_unlock_dcache(inode
);
270 int ll_revalidate_it_finish(struct ptlrpc_request
*request
,
271 struct lookup_intent
*it
,
279 if (it_disposition(it
, DISP_LOOKUP_NEG
))
282 rc
= ll_prep_inode(&inode
, request
, NULL
, it
);
287 void ll_lookup_finish_locks(struct lookup_intent
*it
, struct inode
*inode
)
291 if (it
->d
.lustre
.it_lock_mode
&& inode
!= NULL
) {
292 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
294 CDEBUG(D_DLMTRACE
, "setting l_data to inode %p (%lu/%u)\n",
295 inode
, inode
->i_ino
, inode
->i_generation
);
296 ll_set_lock_data(sbi
->ll_md_exp
, inode
, it
, NULL
);
299 /* drop lookup or getattr locks immediately */
300 if (it
->it_op
== IT_LOOKUP
|| it
->it_op
== IT_GETATTR
) {
301 /* on 2.6 there are situation when several lookups and
302 * revalidations may be requested during single operation.
303 * therefore, we don't release intent here -bzzz */
304 ll_intent_drop_lock(it
);
308 static int ll_revalidate_dentry(struct dentry
*dentry
,
309 unsigned int lookup_flags
)
311 struct inode
*dir
= d_inode(dentry
->d_parent
);
314 * if open&create is set, talk to MDS to make sure file is created if
315 * necessary, because we can't do this in ->open() later since that's
316 * called on an inode. return 0 here to let lookup to handle this.
318 if ((lookup_flags
& (LOOKUP_OPEN
| LOOKUP_CREATE
)) ==
319 (LOOKUP_OPEN
| LOOKUP_CREATE
))
322 if (lookup_flags
& (LOOKUP_PARENT
| LOOKUP_OPEN
| LOOKUP_CREATE
))
325 if (d_need_statahead(dir
, dentry
) <= 0)
328 if (lookup_flags
& LOOKUP_RCU
)
331 do_statahead_enter(dir
, &dentry
, !d_inode(dentry
));
332 ll_statahead_mark(dir
, dentry
);
337 * Always trust cached dentries. Update statahead window if necessary.
339 static int ll_revalidate_nd(struct dentry
*dentry
, unsigned int flags
)
341 CDEBUG(D_VFSTRACE
, "VFS Op:name=%pd, flags=%u\n",
344 return ll_revalidate_dentry(dentry
, flags
);
347 static void ll_d_iput(struct dentry
*de
, struct inode
*inode
)
350 if (!find_cbdata(inode
))
355 const struct dentry_operations ll_d_ops
= {
356 .d_revalidate
= ll_revalidate_nd
,
357 .d_release
= ll_release
,
358 .d_delete
= ll_ddelete
,
360 .d_compare
= ll_dcompare
,