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, 2012, 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 <obd_support.h>
44 #include <lustre_lite.h>
45 #include <lustre/lustre_idl.h>
46 #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
== NULL
) /* NFS copies the de->d_op methods (bug 4655) */
69 ll_intent_release(lld
->lld_it
);
70 OBD_FREE(lld
->lld_it
, sizeof(*lld
->lld_it
));
72 LASSERT(lld
->lld_cwd_count
== 0);
73 LASSERT(lld
->lld_mnt_count
== 0);
75 call_rcu(&lld
->lld_rcu_head
, free_dentry_data
);
78 /* Compare if two dentries are the same. Don't match if the existing dentry
79 * is marked invalid. Returns 1 if different, 0 if the same.
81 * This avoids a race where ll_lookup_it() instantiates a dentry, but we get
82 * an AST before calling d_revalidate_it(). The dentry still exists (marked
83 * INVALID) so d_lookup() matches it, but we have no lock on it (so
84 * lock_match() fails) and we spin around real_lookup(). */
85 int ll_dcompare(const struct dentry
*parent
, const struct dentry
*dentry
,
86 unsigned int len
, const char *str
, 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 %.*s (%p, parent %p, inode %p) %s%s\n",
155 d_lustre_invalid((struct dentry
*)de
) ? "deleting" : "keeping",
156 de
->d_name
.len
, de
->d_name
.name
, de
, de
->d_parent
, de
->d_inode
,
157 d_unhashed((struct dentry
*)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 (de
->d_inode
&& !find_cbdata(de
->d_inode
))
171 clear_nlink(de
->d_inode
);
174 if (d_lustre_invalid((struct dentry
*)de
))
179 int ll_d_init(struct dentry
*de
)
183 CDEBUG(D_DENTRY
, "ldd on dentry %.*s (%p) parent %p inode %p refc %d\n",
184 de
->d_name
.len
, de
->d_name
.name
, de
, de
->d_parent
, de
->d_inode
,
187 if (de
->d_fsdata
== NULL
) {
188 struct ll_dentry_data
*lld
;
191 if (likely(lld
!= NULL
)) {
192 spin_lock(&de
->d_lock
);
193 if (likely(de
->d_fsdata
== NULL
)) {
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 "LPX64
217 " from it %p\n", handle
.cookie
, it
);
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"
227 LPX64
" from it %p\n", handle
.cookie
, it
);
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 */
242 if (it_disposition(it
, DISP_ENQ_CREATE_REF
)) /* create rec */
243 ptlrpc_req_finished(it
->d
.lustre
.it_data
);
245 it
->d
.lustre
.it_disposition
= 0;
246 it
->d
.lustre
.it_data
= NULL
;
249 void ll_invalidate_aliases(struct inode
*inode
)
251 struct dentry
*dentry
;
252 struct ll_d_hlist_node
*p
;
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 ll_d_hlist_for_each_entry(dentry
, p
, &inode
->i_dentry
, d_alias
) {
261 CDEBUG(D_DENTRY
, "dentry in drop %.*s (%p) parent %p "
262 "inode %p flags %d\n", dentry
->d_name
.len
,
263 dentry
->d_name
.name
, dentry
, dentry
->d_parent
,
264 dentry
->d_inode
, dentry
->d_flags
);
266 if (unlikely(dentry
== dentry
->d_sb
->s_root
)) {
267 CERROR("%s: called on root dentry=%p, fid="DFID
"\n",
268 ll_get_fsname(dentry
->d_sb
, NULL
, 0),
269 dentry
, PFID(ll_inode2fid(inode
)));
270 lustre_dump_dentry(dentry
, 1);
274 d_lustre_invalidate(dentry
, 0);
276 ll_unlock_dcache(inode
);
279 int ll_revalidate_it_finish(struct ptlrpc_request
*request
,
280 struct lookup_intent
*it
,
288 if (it_disposition(it
, DISP_LOOKUP_NEG
))
291 rc
= ll_prep_inode(&de
->d_inode
, request
, NULL
, it
);
296 void ll_lookup_finish_locks(struct lookup_intent
*it
, struct dentry
*dentry
)
299 LASSERT(dentry
!= NULL
);
301 if (it
->d
.lustre
.it_lock_mode
&& dentry
->d_inode
!= NULL
) {
302 struct inode
*inode
= dentry
->d_inode
;
303 struct ll_sb_info
*sbi
= ll_i2sbi(dentry
->d_inode
);
305 CDEBUG(D_DLMTRACE
, "setting l_data to inode %p (%lu/%u)\n",
306 inode
, inode
->i_ino
, inode
->i_generation
);
307 ll_set_lock_data(sbi
->ll_md_exp
, inode
, it
, NULL
);
310 /* drop lookup or getattr locks immediately */
311 if (it
->it_op
== IT_LOOKUP
|| it
->it_op
== IT_GETATTR
) {
312 /* on 2.6 there are situation when several lookups and
313 * revalidations may be requested during single operation.
314 * therefore, we don't release intent here -bzzz */
315 ll_intent_drop_lock(it
);
319 void ll_frob_intent(struct lookup_intent
**itp
, struct lookup_intent
*deft
)
321 struct lookup_intent
*it
= *itp
;
323 if (!it
|| it
->it_op
== IT_GETXATTR
)
328 static int ll_revalidate_dentry(struct dentry
*dentry
,
329 unsigned int lookup_flags
)
331 struct inode
*dir
= dentry
->d_parent
->d_inode
;
334 * if open&create is set, talk to MDS to make sure file is created if
335 * necessary, because we can't do this in ->open() later since that's
336 * called on an inode. return 0 here to let lookup to handle this.
338 if ((lookup_flags
& (LOOKUP_OPEN
| LOOKUP_CREATE
)) ==
339 (LOOKUP_OPEN
| LOOKUP_CREATE
))
342 if (lookup_flags
& (LOOKUP_PARENT
| LOOKUP_OPEN
| LOOKUP_CREATE
))
345 if (d_need_statahead(dir
, dentry
) <= 0)
348 if (lookup_flags
& LOOKUP_RCU
)
351 do_statahead_enter(dir
, &dentry
, dentry
->d_inode
== NULL
);
352 ll_statahead_mark(dir
, dentry
);
357 * Always trust cached dentries. Update statahead window if necessary.
359 int ll_revalidate_nd(struct dentry
*dentry
, unsigned int flags
)
363 CDEBUG(D_VFSTRACE
, "VFS Op:name=%s, flags=%u\n",
364 dentry
->d_name
.name
, flags
);
366 rc
= ll_revalidate_dentry(dentry
, flags
);
371 void ll_d_iput(struct dentry
*de
, struct inode
*inode
)
374 if (!find_cbdata(inode
))
379 struct dentry_operations ll_d_ops
= {
380 .d_revalidate
= ll_revalidate_nd
,
381 .d_release
= ll_release
,
382 .d_delete
= ll_ddelete
,
384 .d_compare
= ll_dcompare
,