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.gnu.org/licenses/gpl-2.0.html
23 * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Use is subject to license terms.
26 * Copyright (c) 2011, 2015, Intel Corporation.
29 * This file is part of Lustre, http://www.lustre.org/
30 * Lustre is a trademark of Sun Microsystems, Inc.
34 #include <linux/sched.h>
35 #include <linux/quotaops.h>
37 #define DEBUG_SUBSYSTEM S_LLITE
39 #include "../include/obd_support.h"
40 #include "../include/lustre_lite.h"
41 #include "../include/lustre/lustre_idl.h"
42 #include "../include/lustre_dlm.h"
44 #include "llite_internal.h"
46 static void free_dentry_data(struct rcu_head
*head
)
48 struct ll_dentry_data
*lld
;
50 lld
= container_of(head
, struct ll_dentry_data
, lld_rcu_head
);
54 /* should NOT be called with the dcache lock, see fs/dcache.c */
55 static void ll_release(struct dentry
*de
)
57 struct ll_dentry_data
*lld
;
61 if (!lld
) /* NFS copies the de->d_op methods (bug 4655) */
65 ll_intent_release(lld
->lld_it
);
70 call_rcu(&lld
->lld_rcu_head
, free_dentry_data
);
73 /* Compare if two dentries are the same. Don't match if the existing dentry
74 * is marked invalid. Returns 1 if different, 0 if the same.
76 * This avoids a race where ll_lookup_it() instantiates a dentry, but we get
77 * an AST before calling d_revalidate_it(). The dentry still exists (marked
78 * INVALID) so d_lookup() matches it, but we have no lock on it (so
79 * lock_match() fails) and we spin around real_lookup().
81 static int ll_dcompare(const struct dentry
*dentry
,
82 unsigned int len
, const char *str
,
83 const struct qstr
*name
)
88 if (memcmp(str
, name
->name
, len
))
91 CDEBUG(D_DENTRY
, "found name %.*s(%p) flags %#x refc %d\n",
92 name
->len
, name
->name
, dentry
, dentry
->d_flags
,
95 /* mountpoint is always valid */
96 if (d_mountpoint((struct dentry
*)dentry
))
99 if (d_lustre_invalid(dentry
))
105 static inline int return_if_equal(struct ldlm_lock
*lock
, void *data
)
107 return (ldlm_is_canceling(lock
) && ldlm_is_discard_data(lock
)) ?
108 LDLM_ITER_CONTINUE
: LDLM_ITER_STOP
;
111 /* find any ldlm lock of the inode in mdc and lov
116 static int find_cbdata(struct inode
*inode
)
118 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
119 struct lov_stripe_md
*lsm
;
123 rc
= md_find_cbdata(sbi
->ll_md_exp
, ll_inode2fid(inode
),
124 return_if_equal
, NULL
);
128 lsm
= ccc_inode_lsm_get(inode
);
132 rc
= obd_find_cbdata(sbi
->ll_dt_exp
, lsm
, return_if_equal
, NULL
);
133 ccc_inode_lsm_put(inode
, lsm
);
139 * Called when last reference to a dentry is dropped and dcache wants to know
140 * whether or not it should cache it:
141 * - return 1 to delete the dentry immediately
142 * - return 0 to cache the dentry
143 * Should NOT be called with the dcache lock, see fs/dcache.c
145 static int ll_ddelete(const struct dentry
*de
)
149 CDEBUG(D_DENTRY
, "%s dentry %pd (%p, parent %p, inode %p) %s%s\n",
150 d_lustre_invalid((struct dentry
*)de
) ? "deleting" : "keeping",
151 de
, de
, de
->d_parent
, d_inode(de
),
152 d_unhashed(de
) ? "" : "hashed,",
153 list_empty(&de
->d_subdirs
) ? "" : "subdirs");
155 /* kernel >= 2.6.38 last refcount is decreased after this function. */
156 LASSERT(d_count(de
) == 1);
158 /* Disable this piece of code temporarily because this is called
159 * inside dcache_lock so it's not appropriate to do lots of work
160 * here. ATTENTION: Before this piece of code enabling, LU-2487 must be
164 /* if not ldlm lock for this inode, set i_nlink to 0 so that
165 * this inode can be recycled later b=20433
167 if (d_really_is_positive(de
) && !find_cbdata(d_inode(de
)))
168 clear_nlink(d_inode(de
));
171 if (d_lustre_invalid((struct dentry
*)de
))
176 int ll_d_init(struct dentry
*de
)
178 CDEBUG(D_DENTRY
, "ldd on dentry %pd (%p) parent %p inode %p refc %d\n",
179 de
, de
, de
->d_parent
, d_inode(de
), d_count(de
));
182 struct ll_dentry_data
*lld
;
184 lld
= kzalloc(sizeof(*lld
), GFP_NOFS
);
186 spin_lock(&de
->d_lock
);
187 if (likely(!de
->d_fsdata
)) {
189 __d_lustre_invalidate(de
);
193 spin_unlock(&de
->d_lock
);
198 LASSERT(de
->d_op
== &ll_d_ops
);
203 void ll_intent_drop_lock(struct lookup_intent
*it
)
205 if (it
->it_op
&& it
->it_lock_mode
) {
206 struct lustre_handle handle
;
208 handle
.cookie
= it
->it_lock_handle
;
210 CDEBUG(D_DLMTRACE
, "releasing lock with cookie %#llx from it %p\n",
212 ldlm_lock_decref(&handle
, it
->it_lock_mode
);
214 /* bug 494: intent_release may be called multiple times, from
215 * this thread and we don't want to double-decref this lock
217 it
->it_lock_mode
= 0;
218 if (it
->it_remote_lock_mode
!= 0) {
219 handle
.cookie
= it
->it_remote_lock_handle
;
221 CDEBUG(D_DLMTRACE
, "releasing remote lock with cookie%#llx from it %p\n",
223 ldlm_lock_decref(&handle
,
224 it
->it_remote_lock_mode
);
225 it
->it_remote_lock_mode
= 0;
230 void ll_intent_release(struct lookup_intent
*it
)
232 CDEBUG(D_INFO
, "intent %p released\n", it
);
233 ll_intent_drop_lock(it
);
234 /* We are still holding extra reference on a request, need to free it */
235 if (it_disposition(it
, DISP_ENQ_OPEN_REF
))
236 ptlrpc_req_finished(it
->it_request
); /* ll_file_open */
238 if (it_disposition(it
, DISP_ENQ_CREATE_REF
)) /* create rec */
239 ptlrpc_req_finished(it
->it_request
);
241 it
->it_disposition
= 0;
242 it
->it_request
= NULL
;
245 void ll_invalidate_aliases(struct inode
*inode
)
247 struct dentry
*dentry
;
249 CDEBUG(D_INODE
, "marking dentries for ino "DFID
"(%p) invalid\n",
250 PFID(ll_inode2fid(inode
)), inode
);
252 spin_lock(&inode
->i_lock
);
253 hlist_for_each_entry(dentry
, &inode
->i_dentry
, d_u
.d_alias
) {
254 CDEBUG(D_DENTRY
, "dentry in drop %pd (%p) parent %p inode %p flags %d\n",
255 dentry
, dentry
, dentry
->d_parent
,
256 d_inode(dentry
), dentry
->d_flags
);
258 d_lustre_invalidate(dentry
, 0);
260 spin_unlock(&inode
->i_lock
);
263 int ll_revalidate_it_finish(struct ptlrpc_request
*request
,
264 struct lookup_intent
*it
,
272 if (it_disposition(it
, DISP_LOOKUP_NEG
))
275 rc
= ll_prep_inode(&inode
, request
, NULL
, it
);
280 void ll_lookup_finish_locks(struct lookup_intent
*it
, struct inode
*inode
)
282 if (it
->it_lock_mode
&& inode
) {
283 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
285 CDEBUG(D_DLMTRACE
, "setting l_data to inode "DFID
"(%p)\n",
286 PFID(ll_inode2fid(inode
)), inode
);
287 ll_set_lock_data(sbi
->ll_md_exp
, inode
, it
, NULL
);
290 /* drop lookup or getattr locks immediately */
291 if (it
->it_op
== IT_LOOKUP
|| it
->it_op
== IT_GETATTR
) {
292 /* on 2.6 there are situation when several lookups and
293 * revalidations may be requested during single operation.
294 * therefore, we don't release intent here -bzzz
296 ll_intent_drop_lock(it
);
300 static int ll_revalidate_dentry(struct dentry
*dentry
,
301 unsigned int lookup_flags
)
303 struct inode
*dir
= d_inode(dentry
->d_parent
);
305 /* If this is intermediate component path lookup and we were able to get
306 * to this dentry, then its lock has not been revoked and the
307 * path component is valid.
309 if (lookup_flags
& LOOKUP_PARENT
)
312 /* Symlink - always valid as long as the dentry was found */
313 if (dentry
->d_inode
&& S_ISLNK(dentry
->d_inode
->i_mode
))
317 * if open&create is set, talk to MDS to make sure file is created if
318 * necessary, because we can't do this in ->open() later since that's
319 * called on an inode. return 0 here to let lookup to handle this.
321 if ((lookup_flags
& (LOOKUP_OPEN
| LOOKUP_CREATE
)) ==
322 (LOOKUP_OPEN
| LOOKUP_CREATE
))
325 if (lookup_flags
& (LOOKUP_PARENT
| LOOKUP_OPEN
| LOOKUP_CREATE
))
328 if (d_need_statahead(dir
, dentry
) <= 0)
331 if (lookup_flags
& LOOKUP_RCU
)
334 do_statahead_enter(dir
, &dentry
, !d_inode(dentry
));
335 ll_statahead_mark(dir
, dentry
);
340 * Always trust cached dentries. Update statahead window if necessary.
342 static int ll_revalidate_nd(struct dentry
*dentry
, unsigned int flags
)
344 CDEBUG(D_VFSTRACE
, "VFS Op:name=%pd, flags=%u\n",
347 return ll_revalidate_dentry(dentry
, flags
);
350 static void ll_d_iput(struct dentry
*de
, struct inode
*inode
)
353 if (!find_cbdata(inode
))
358 const struct dentry_operations ll_d_ops
= {
359 .d_revalidate
= ll_revalidate_nd
,
360 .d_release
= ll_release
,
361 .d_delete
= ll_ddelete
,
363 .d_compare
= ll_dcompare
,