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) 2007, 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.
36 * lustre/include/md_object.h
38 * Extension of lu_object.h for metadata objects
41 #ifndef _LUSTRE_MD_OBJECT_H
42 #define _LUSTRE_MD_OBJECT_H
45 * Sub-class of lu_object with methods common for "meta-data" objects in MDT
48 * Meta-data objects implement namespace operations: you can link, unlink
49 * them, and treat them as directories.
51 * Examples: mdt, cmm, and mdt are implementations of md interface.
57 * super-class definitions.
59 #include "dt_object.h"
62 struct md_device_operations
;
77 /** there are at most 5 fids in one operation, see rename, NOTE the last one
78 * is a temporary one used for is_subdir() */
82 struct lu_fid mc_fid
[MD_CAPAINFO_MAX
];
83 struct lustre_capa
*mc_capa
[MD_CAPAINFO_MAX
];
87 struct obd_export
*mq_exp
;
91 * Implemented in mdd/mdd_handler.c.
93 * XXX should be moved into separate .h/.c together with all md security
94 * related definitions.
96 struct md_capainfo
*md_capainfo(const struct lu_env
*env
);
97 struct md_quota
*md_quota(const struct lu_env
*env
);
99 /** metadata attributes */
103 MA_COOKIE
= (1 << 2),
106 MA_ACL_DEF
= (1 << 5),
107 MA_LOV_DEF
= (1 << 6),
108 MA_LAY_GEN
= (1 << 7),
128 MDT_REG_LOCK
= (1 << 0),
129 MDT_PDO_LOCK
= (1 << 1)
132 /* memory structure for hsm attributes
133 * for fields description see the on disk structure hsm_attrs
134 * which is defined in lustre_idl.h
143 #define IOEPOCH_INVAL 0
145 /* memory structure for som attributes
146 * for fields description see the on disk structure som_attrs
147 * which is defined in lustre_idl.h
162 struct lu_attr ma_attr
;
163 struct lu_fid ma_pfid
;
164 struct md_hsm ma_hsm
;
165 struct lov_mds_md
*ma_lmm
;
166 struct lmv_stripe_md
*ma_lmv
;
168 struct llog_cookie
*ma_cookie
;
169 struct lustre_capa
*ma_capa
;
170 struct md_som_data
*ma_som
;
178 /** Additional parameters for create */
181 /** symlink target */
182 const char *sp_symname
;
183 /** parent FID for cross-ref mkdir */
184 const struct lu_fid
*sp_pfid
;
185 /** eadata for regular files */
187 /** lov objs exist already */
188 const struct lu_fid
*fid
;
194 /** Create flag from client: such as MDS_OPEN_CREAT, and others. */
197 /** don't create lov objects or llog cookie - this replay */
198 unsigned int no_create
:1,
199 sp_cr_lookup
:1, /* do lookup sanity check or not. */
200 sp_rm_entry
:1; /* only remove name entry */
202 /** Current lock mode for parent dir where create is performing. */
203 mdl_mode_t sp_cr_mode
;
205 /** to create directory */
206 const struct dt_index_features
*sp_feat
;
210 * Operations implemented for each md object (both directory and leaf).
212 struct md_object_operations
{
213 int (*moo_permission
)(const struct lu_env
*env
,
214 struct md_object
*pobj
, struct md_object
*cobj
,
215 struct md_attr
*attr
, int mask
);
217 int (*moo_attr_get
)(const struct lu_env
*env
, struct md_object
*obj
,
218 struct md_attr
*attr
);
220 int (*moo_attr_set
)(const struct lu_env
*env
, struct md_object
*obj
,
221 const struct md_attr
*attr
);
223 int (*moo_xattr_get
)(const struct lu_env
*env
, struct md_object
*obj
,
224 struct lu_buf
*buf
, const char *name
);
226 int (*moo_xattr_list
)(const struct lu_env
*env
, struct md_object
*obj
,
229 int (*moo_xattr_set
)(const struct lu_env
*env
, struct md_object
*obj
,
230 const struct lu_buf
*buf
, const char *name
,
233 int (*moo_xattr_del
)(const struct lu_env
*env
, struct md_object
*obj
,
236 /** This method is used to swap the layouts between 2 objects */
237 int (*moo_swap_layouts
)(const struct lu_env
*env
,
238 struct md_object
*obj1
, struct md_object
*obj2
,
241 /** \retval number of bytes actually read upon success */
242 int (*moo_readpage
)(const struct lu_env
*env
, struct md_object
*obj
,
243 const struct lu_rdpg
*rdpg
);
245 int (*moo_readlink
)(const struct lu_env
*env
, struct md_object
*obj
,
247 int (*moo_changelog
)(const struct lu_env
*env
,
248 enum changelog_rec_type type
, int flags
,
249 struct md_object
*obj
);
250 /** part of cross-ref operation */
251 int (*moo_object_create
)(const struct lu_env
*env
,
252 struct md_object
*obj
,
253 const struct md_op_spec
*spec
,
256 int (*moo_ref_add
)(const struct lu_env
*env
,
257 struct md_object
*obj
,
258 const struct md_attr
*ma
);
260 int (*moo_ref_del
)(const struct lu_env
*env
,
261 struct md_object
*obj
,
264 int (*moo_open
)(const struct lu_env
*env
,
265 struct md_object
*obj
, int flag
);
267 int (*moo_close
)(const struct lu_env
*env
, struct md_object
*obj
,
268 struct md_attr
*ma
, int mode
);
270 int (*moo_capa_get
)(const struct lu_env
*, struct md_object
*,
271 struct lustre_capa
*, int renewal
);
273 int (*moo_object_sync
)(const struct lu_env
*, struct md_object
*);
275 int (*moo_file_lock
)(const struct lu_env
*env
, struct md_object
*obj
,
276 struct lov_mds_md
*lmm
, struct ldlm_extent
*extent
,
277 struct lustre_handle
*lockh
);
278 int (*moo_file_unlock
)(const struct lu_env
*env
, struct md_object
*obj
,
279 struct lov_mds_md
*lmm
,
280 struct lustre_handle
*lockh
);
281 int (*moo_object_lock
)(const struct lu_env
*env
, struct md_object
*obj
,
282 struct lustre_handle
*lh
,
283 struct ldlm_enqueue_info
*einfo
,
288 * Operations implemented for each directory object.
290 struct md_dir_operations
{
291 int (*mdo_is_subdir
) (const struct lu_env
*env
, struct md_object
*obj
,
292 const struct lu_fid
*fid
, struct lu_fid
*sfid
);
294 int (*mdo_lookup
)(const struct lu_env
*env
, struct md_object
*obj
,
295 const struct lu_name
*lname
, struct lu_fid
*fid
,
296 struct md_op_spec
*spec
);
298 mdl_mode_t (*mdo_lock_mode
)(const struct lu_env
*env
,
299 struct md_object
*obj
,
302 int (*mdo_create
)(const struct lu_env
*env
, struct md_object
*pobj
,
303 const struct lu_name
*lname
, struct md_object
*child
,
304 struct md_op_spec
*spec
,
307 /** This method is used for creating data object for this meta object*/
308 int (*mdo_create_data
)(const struct lu_env
*env
, struct md_object
*p
,
310 const struct md_op_spec
*spec
,
313 int (*mdo_rename
)(const struct lu_env
*env
, struct md_object
*spobj
,
314 struct md_object
*tpobj
, const struct lu_fid
*lf
,
315 const struct lu_name
*lsname
, struct md_object
*tobj
,
316 const struct lu_name
*ltname
, struct md_attr
*ma
);
318 int (*mdo_link
)(const struct lu_env
*env
, struct md_object
*tgt_obj
,
319 struct md_object
*src_obj
, const struct lu_name
*lname
,
322 int (*mdo_unlink
)(const struct lu_env
*env
, struct md_object
*pobj
,
323 struct md_object
*cobj
, const struct lu_name
*lname
,
324 struct md_attr
*ma
, int no_name
);
326 /** This method is used to compare a requested layout to an existing
327 * layout (struct lov_mds_md_v1/3 vs struct lov_mds_md_v1/3) */
328 int (*mdo_lum_lmm_cmp
)(const struct lu_env
*env
,
329 struct md_object
*cobj
,
330 const struct md_op_spec
*spec
,
333 /** partial ops for cross-ref case */
334 int (*mdo_name_insert
)(const struct lu_env
*env
,
335 struct md_object
*obj
,
336 const struct lu_name
*lname
,
337 const struct lu_fid
*fid
,
338 const struct md_attr
*ma
);
340 int (*mdo_name_remove
)(const struct lu_env
*env
,
341 struct md_object
*obj
,
342 const struct lu_name
*lname
,
343 const struct md_attr
*ma
);
345 int (*mdo_rename_tgt
)(const struct lu_env
*env
, struct md_object
*pobj
,
346 struct md_object
*tobj
, const struct lu_fid
*fid
,
347 const struct lu_name
*lname
, struct md_attr
*ma
);
350 struct md_device_operations
{
351 /** meta-data device related handlers. */
352 int (*mdo_root_get
)(const struct lu_env
*env
, struct md_device
*m
,
355 int (*mdo_maxeasize_get
)(const struct lu_env
*env
, struct md_device
*m
,
358 int (*mdo_statfs
)(const struct lu_env
*env
, struct md_device
*m
,
359 struct obd_statfs
*sfs
);
361 int (*mdo_init_capa_ctxt
)(const struct lu_env
*env
, struct md_device
*m
,
362 int mode
, unsigned long timeout
, __u32 alg
,
363 struct lustre_capa_key
*keys
);
365 int (*mdo_update_capa_key
)(const struct lu_env
*env
,
367 struct lustre_capa_key
*key
);
369 int (*mdo_llog_ctxt_get
)(const struct lu_env
*env
,
370 struct md_device
*m
, int idx
, void **h
);
372 int (*mdo_iocontrol
)(const struct lu_env
*env
, struct md_device
*m
,
373 unsigned int cmd
, int len
, void *data
);
376 enum md_upcall_event
{
377 /** Sync the md layer*/
378 MD_LOV_SYNC
= (1 << 0),
379 /** Just for split, no need trans, for replay */
380 MD_NO_TRANS
= (1 << 1),
381 MD_LOV_CONFIG
= (1 << 2),
382 /** Trigger quota recovery */
383 MD_LOV_QUOTA
= (1 << 3)
387 /** this lock protects upcall using against its removal
388 * read lock is for usage the upcall, write - for init/fini */
389 struct rw_semaphore mu_upcall_sem
;
390 /** device to call, upper layer normally */
391 struct md_device
*mu_upcall_dev
;
392 /** upcall function */
393 int (*mu_upcall
)(const struct lu_env
*env
, struct md_device
*md
,
394 enum md_upcall_event ev
, void *data
);
398 struct lu_device md_lu_dev
;
399 const struct md_device_operations
*md_ops
;
400 struct md_upcall md_upcall
;
403 static inline void md_upcall_init(struct md_device
*m
, void *upcl
)
405 init_rwsem(&m
->md_upcall
.mu_upcall_sem
);
406 m
->md_upcall
.mu_upcall_dev
= NULL
;
407 m
->md_upcall
.mu_upcall
= upcl
;
410 static inline void md_upcall_dev_set(struct md_device
*m
, struct md_device
*up
)
412 down_write(&m
->md_upcall
.mu_upcall_sem
);
413 m
->md_upcall
.mu_upcall_dev
= up
;
414 up_write(&m
->md_upcall
.mu_upcall_sem
);
417 static inline void md_upcall_fini(struct md_device
*m
)
419 down_write(&m
->md_upcall
.mu_upcall_sem
);
420 m
->md_upcall
.mu_upcall_dev
= NULL
;
421 m
->md_upcall
.mu_upcall
= NULL
;
422 up_write(&m
->md_upcall
.mu_upcall_sem
);
425 static inline int md_do_upcall(const struct lu_env
*env
, struct md_device
*m
,
426 enum md_upcall_event ev
, void *data
)
429 down_read(&m
->md_upcall
.mu_upcall_sem
);
430 if (m
->md_upcall
.mu_upcall_dev
!= NULL
&&
431 m
->md_upcall
.mu_upcall_dev
->md_upcall
.mu_upcall
!= NULL
) {
432 rc
= m
->md_upcall
.mu_upcall_dev
->md_upcall
.mu_upcall(env
,
433 m
->md_upcall
.mu_upcall_dev
,
436 up_read(&m
->md_upcall
.mu_upcall_sem
);
441 struct lu_object mo_lu
;
442 const struct md_object_operations
*mo_ops
;
443 const struct md_dir_operations
*mo_dir_ops
;
449 struct seq_server_site
{
450 struct lu_site
*ss_lu
;
452 * mds number of this site.
456 * Fid location database
458 struct lu_server_fld
*ss_server_fld
;
459 struct lu_client_fld
*ss_client_fld
;
464 struct lu_server_seq
*ss_server_seq
;
467 * Controller Seq Manager
469 struct lu_server_seq
*ss_control_seq
;
470 struct obd_export
*ss_control_exp
;
475 struct lu_client_seq
*ss_client_seq
;
478 static inline struct md_device
*lu2md_dev(const struct lu_device
*d
)
480 LASSERT(IS_ERR(d
) || lu_device_is_md(d
));
481 return container_of0(d
, struct md_device
, md_lu_dev
);
484 static inline struct lu_device
*md2lu_dev(struct md_device
*d
)
486 return &d
->md_lu_dev
;
489 static inline struct md_object
*lu2md(const struct lu_object
*o
)
491 LASSERT(o
== NULL
|| IS_ERR(o
) || lu_device_is_md(o
->lo_dev
));
492 return container_of0(o
, struct md_object
, mo_lu
);
495 static inline struct md_object
*md_object_next(const struct md_object
*obj
)
497 return (obj
? lu2md(lu_object_next(&obj
->mo_lu
)) : NULL
);
500 static inline struct md_device
*md_obj2dev(const struct md_object
*o
)
502 LASSERT(o
== NULL
|| IS_ERR(o
) || lu_device_is_md(o
->mo_lu
.lo_dev
));
503 return container_of0(o
->mo_lu
.lo_dev
, struct md_device
, md_lu_dev
);
506 static inline int md_device_init(struct md_device
*md
, struct lu_device_type
*t
)
508 return lu_device_init(&md
->md_lu_dev
, t
);
511 static inline void md_device_fini(struct md_device
*md
)
513 lu_device_fini(&md
->md_lu_dev
);
516 static inline struct md_object
*md_object_find_slice(const struct lu_env
*env
,
517 struct md_device
*md
,
518 const struct lu_fid
*f
)
520 return lu2md(lu_object_find_slice(env
, md2lu_dev(md
), f
, NULL
));
525 static inline int mo_permission(const struct lu_env
*env
,
531 LASSERT(c
->mo_ops
->moo_permission
);
532 return c
->mo_ops
->moo_permission(env
, p
, c
, at
, mask
);
535 static inline int mo_attr_get(const struct lu_env
*env
,
539 LASSERT(m
->mo_ops
->moo_attr_get
);
540 return m
->mo_ops
->moo_attr_get(env
, m
, at
);
543 static inline int mo_readlink(const struct lu_env
*env
,
547 LASSERT(m
->mo_ops
->moo_readlink
);
548 return m
->mo_ops
->moo_readlink(env
, m
, buf
);
551 static inline int mo_changelog(const struct lu_env
*env
,
552 enum changelog_rec_type type
,
553 int flags
, struct md_object
*m
)
555 LASSERT(m
->mo_ops
->moo_changelog
);
556 return m
->mo_ops
->moo_changelog(env
, type
, flags
, m
);
559 static inline int mo_attr_set(const struct lu_env
*env
,
561 const struct md_attr
*at
)
563 LASSERT(m
->mo_ops
->moo_attr_set
);
564 return m
->mo_ops
->moo_attr_set(env
, m
, at
);
567 static inline int mo_xattr_get(const struct lu_env
*env
,
572 LASSERT(m
->mo_ops
->moo_xattr_get
);
573 return m
->mo_ops
->moo_xattr_get(env
, m
, buf
, name
);
576 static inline int mo_xattr_del(const struct lu_env
*env
,
580 LASSERT(m
->mo_ops
->moo_xattr_del
);
581 return m
->mo_ops
->moo_xattr_del(env
, m
, name
);
584 static inline int mo_xattr_set(const struct lu_env
*env
,
586 const struct lu_buf
*buf
,
590 LASSERT(m
->mo_ops
->moo_xattr_set
);
591 return m
->mo_ops
->moo_xattr_set(env
, m
, buf
, name
, flags
);
594 static inline int mo_xattr_list(const struct lu_env
*env
,
598 LASSERT(m
->mo_ops
->moo_xattr_list
);
599 return m
->mo_ops
->moo_xattr_list(env
, m
, buf
);
602 static inline int mo_swap_layouts(const struct lu_env
*env
,
603 struct md_object
*o1
,
604 struct md_object
*o2
, __u64 flags
)
606 LASSERT(o1
->mo_ops
->moo_swap_layouts
);
607 LASSERT(o2
->mo_ops
->moo_swap_layouts
);
608 if (o1
->mo_ops
->moo_swap_layouts
!= o2
->mo_ops
->moo_swap_layouts
)
610 return o1
->mo_ops
->moo_swap_layouts(env
, o1
, o2
, flags
);
613 static inline int mo_open(const struct lu_env
*env
,
617 LASSERT(m
->mo_ops
->moo_open
);
618 return m
->mo_ops
->moo_open(env
, m
, flags
);
621 static inline int mo_close(const struct lu_env
*env
,
626 LASSERT(m
->mo_ops
->moo_close
);
627 return m
->mo_ops
->moo_close(env
, m
, ma
, mode
);
630 static inline int mo_readpage(const struct lu_env
*env
,
632 const struct lu_rdpg
*rdpg
)
634 LASSERT(m
->mo_ops
->moo_readpage
);
635 return m
->mo_ops
->moo_readpage(env
, m
, rdpg
);
638 static inline int mo_object_create(const struct lu_env
*env
,
640 const struct md_op_spec
*spc
,
643 LASSERT(m
->mo_ops
->moo_object_create
);
644 return m
->mo_ops
->moo_object_create(env
, m
, spc
, at
);
647 static inline int mo_ref_add(const struct lu_env
*env
,
649 const struct md_attr
*ma
)
651 LASSERT(m
->mo_ops
->moo_ref_add
);
652 return m
->mo_ops
->moo_ref_add(env
, m
, ma
);
655 static inline int mo_ref_del(const struct lu_env
*env
,
659 LASSERT(m
->mo_ops
->moo_ref_del
);
660 return m
->mo_ops
->moo_ref_del(env
, m
, ma
);
663 static inline int mo_capa_get(const struct lu_env
*env
,
665 struct lustre_capa
*c
,
668 LASSERT(m
->mo_ops
->moo_capa_get
);
669 return m
->mo_ops
->moo_capa_get(env
, m
, c
, renewal
);
672 static inline int mo_object_sync(const struct lu_env
*env
, struct md_object
*m
)
674 LASSERT(m
->mo_ops
->moo_object_sync
);
675 return m
->mo_ops
->moo_object_sync(env
, m
);
678 static inline int mo_file_lock(const struct lu_env
*env
, struct md_object
*m
,
679 struct lov_mds_md
*lmm
,
680 struct ldlm_extent
*extent
,
681 struct lustre_handle
*lockh
)
683 LASSERT(m
->mo_ops
->moo_file_lock
);
684 return m
->mo_ops
->moo_file_lock(env
, m
, lmm
, extent
, lockh
);
687 static inline int mo_file_unlock(const struct lu_env
*env
, struct md_object
*m
,
688 struct lov_mds_md
*lmm
,
689 struct lustre_handle
*lockh
)
691 LASSERT(m
->mo_ops
->moo_file_unlock
);
692 return m
->mo_ops
->moo_file_unlock(env
, m
, lmm
, lockh
);
695 static inline int mo_object_lock(const struct lu_env
*env
,
697 struct lustre_handle
*lh
,
698 struct ldlm_enqueue_info
*einfo
,
701 LASSERT(m
->mo_ops
->moo_object_lock
);
702 return m
->mo_ops
->moo_object_lock(env
, m
, lh
, einfo
, policy
);
705 static inline int mdo_lookup(const struct lu_env
*env
,
707 const struct lu_name
*lname
,
709 struct md_op_spec
*spec
)
711 LASSERT(p
->mo_dir_ops
->mdo_lookup
);
712 return p
->mo_dir_ops
->mdo_lookup(env
, p
, lname
, f
, spec
);
715 static inline mdl_mode_t
mdo_lock_mode(const struct lu_env
*env
,
716 struct md_object
*mo
,
719 if (mo
->mo_dir_ops
->mdo_lock_mode
== NULL
)
721 return mo
->mo_dir_ops
->mdo_lock_mode(env
, mo
, lm
);
724 static inline int mdo_create(const struct lu_env
*env
,
726 const struct lu_name
*lchild_name
,
728 struct md_op_spec
*spc
,
731 LASSERT(p
->mo_dir_ops
->mdo_create
);
732 return p
->mo_dir_ops
->mdo_create(env
, p
, lchild_name
, c
, spc
, at
);
735 static inline int mdo_create_data(const struct lu_env
*env
,
738 const struct md_op_spec
*spec
,
741 LASSERT(c
->mo_dir_ops
->mdo_create_data
);
742 return c
->mo_dir_ops
->mdo_create_data(env
, p
, c
, spec
, ma
);
745 static inline int mdo_rename(const struct lu_env
*env
,
746 struct md_object
*sp
,
747 struct md_object
*tp
,
748 const struct lu_fid
*lf
,
749 const struct lu_name
*lsname
,
751 const struct lu_name
*ltname
,
754 LASSERT(tp
->mo_dir_ops
->mdo_rename
);
755 return tp
->mo_dir_ops
->mdo_rename(env
, sp
, tp
, lf
, lsname
, t
, ltname
,
759 static inline int mdo_is_subdir(const struct lu_env
*env
,
760 struct md_object
*mo
,
761 const struct lu_fid
*fid
,
764 LASSERT(mo
->mo_dir_ops
->mdo_is_subdir
);
765 return mo
->mo_dir_ops
->mdo_is_subdir(env
, mo
, fid
, sfid
);
768 static inline int mdo_link(const struct lu_env
*env
,
771 const struct lu_name
*lname
,
774 LASSERT(s
->mo_dir_ops
->mdo_link
);
775 return s
->mo_dir_ops
->mdo_link(env
, p
, s
, lname
, ma
);
778 static inline int mdo_unlink(const struct lu_env
*env
,
781 const struct lu_name
*lname
,
782 struct md_attr
*ma
, int no_name
)
784 LASSERT(p
->mo_dir_ops
->mdo_unlink
);
785 return p
->mo_dir_ops
->mdo_unlink(env
, p
, c
, lname
, ma
, no_name
);
788 static inline int mdo_lum_lmm_cmp(const struct lu_env
*env
,
790 const struct md_op_spec
*spec
,
793 LASSERT(c
->mo_dir_ops
->mdo_lum_lmm_cmp
);
794 return c
->mo_dir_ops
->mdo_lum_lmm_cmp(env
, c
, spec
, ma
);
797 static inline int mdo_name_insert(const struct lu_env
*env
,
799 const struct lu_name
*lname
,
800 const struct lu_fid
*f
,
801 const struct md_attr
*ma
)
803 LASSERT(p
->mo_dir_ops
->mdo_name_insert
);
804 return p
->mo_dir_ops
->mdo_name_insert(env
, p
, lname
, f
, ma
);
807 static inline int mdo_name_remove(const struct lu_env
*env
,
809 const struct lu_name
*lname
,
810 const struct md_attr
*ma
)
812 LASSERT(p
->mo_dir_ops
->mdo_name_remove
);
813 return p
->mo_dir_ops
->mdo_name_remove(env
, p
, lname
, ma
);
816 static inline int mdo_rename_tgt(const struct lu_env
*env
,
819 const struct lu_fid
*lf
,
820 const struct lu_name
*lname
,
824 LASSERT(t
->mo_dir_ops
->mdo_rename_tgt
);
825 return t
->mo_dir_ops
->mdo_rename_tgt(env
, p
, t
, lf
, lname
, ma
);
827 LASSERT(p
->mo_dir_ops
->mdo_rename_tgt
);
828 return p
->mo_dir_ops
->mdo_rename_tgt(env
, p
, t
, lf
, lname
, ma
);
833 * Used in MDD/OUT layer for object lock rule
835 enum mdd_object_role
{
845 * Structure to hold object information. This is used to create object
846 * \pre llod_dir exist
848 struct lu_local_obj_desc
{
849 const char *llod_dir
;
850 const char *llod_name
;
853 const struct dt_index_features
*llod_feat
;
854 struct list_head llod_linkage
;
857 int lustre_buf2som(void *buf
, int rc
, struct md_som_data
*msd
);
858 int lustre_buf2hsm(void *buf
, int rc
, struct md_hsm
*mh
);
859 void lustre_hsm2buf(void *buf
, struct md_hsm
*mh
);
871 __u32 uc_suppgids
[2];
874 struct group_info
*uc_ginfo
;
875 struct md_identity
*uc_identity
;
878 struct lu_ucred
*lu_ucred(const struct lu_env
*env
);
880 struct lu_ucred
*lu_ucred_check(const struct lu_env
*env
);
882 struct lu_ucred
*lu_ucred_assert(const struct lu_env
*env
);
884 int lu_ucred_global_init(void);
886 void lu_ucred_global_fini(void);
888 #define md_cap_t(x) (x)
890 #define MD_CAP_TO_MASK(x) (1 << (x))
892 #define md_cap_raised(c, flag) (md_cap_t(c) & MD_CAP_TO_MASK(flag))
894 /* capable() is copied from linux kernel! */
895 static inline int md_capable(struct lu_ucred
*uc
, cfs_cap_t cap
)
897 if (md_cap_raised(uc
->uc_cap
, cap
))
903 #endif /* _LINUX_MD_OBJECT_H */