Commit | Line | Data |
---|---|---|
d7e09d03 PT |
1 | /* |
2 | * GPL HEADER START | |
3 | * | |
4 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
5 | * | |
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. | |
9 | * | |
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). | |
15 | * | |
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 | |
19 | * | |
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 | |
22 | * have any questions. | |
23 | * | |
24 | * GPL HEADER END | |
25 | */ | |
26 | /* | |
27 | * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. | |
28 | * Use is subject to license terms. | |
29 | * | |
30 | * Copyright (c) 2011, 2012, Intel Corporation. | |
31 | */ | |
32 | /* | |
33 | * This file is part of Lustre, http://www.lustre.org/ | |
34 | * Lustre is a trademark of Sun Microsystems, Inc. | |
35 | * | |
36 | * lustre/include/md_object.h | |
37 | * | |
17891183 | 38 | * Extension of lu_object.h for metadata objects |
d7e09d03 PT |
39 | */ |
40 | ||
41 | #ifndef _LUSTRE_MD_OBJECT_H | |
42 | #define _LUSTRE_MD_OBJECT_H | |
43 | ||
44 | /** \defgroup md md | |
45 | * Sub-class of lu_object with methods common for "meta-data" objects in MDT | |
46 | * stack. | |
47 | * | |
48 | * Meta-data objects implement namespace operations: you can link, unlink | |
49 | * them, and treat them as directories. | |
50 | * | |
51 | * Examples: mdt, cmm, and mdt are implementations of md interface. | |
52 | * @{ | |
53 | */ | |
54 | ||
55 | ||
56 | /* | |
57 | * super-class definitions. | |
58 | */ | |
1accaadf | 59 | #include "dt_object.h" |
d7e09d03 PT |
60 | |
61 | struct md_device; | |
62 | struct md_device_operations; | |
63 | struct md_object; | |
64 | struct obd_export; | |
65 | ||
66 | enum { | |
67 | UCRED_INVALID = -1, | |
68 | UCRED_INIT = 0, | |
69 | UCRED_OLD = 1, | |
70 | UCRED_NEW = 2 | |
71 | }; | |
72 | ||
73 | enum { | |
74 | MD_CAPAINFO_MAX = 5 | |
75 | }; | |
76 | ||
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() */ | |
79 | struct md_capainfo { | |
80 | __u32 mc_auth; | |
81 | __u32 mc_padding; | |
82 | struct lu_fid mc_fid[MD_CAPAINFO_MAX]; | |
83 | struct lustre_capa *mc_capa[MD_CAPAINFO_MAX]; | |
84 | }; | |
85 | ||
86 | struct md_quota { | |
87 | struct obd_export *mq_exp; | |
88 | }; | |
89 | ||
90 | /** | |
91 | * Implemented in mdd/mdd_handler.c. | |
92 | * | |
93 | * XXX should be moved into separate .h/.c together with all md security | |
94 | * related definitions. | |
95 | */ | |
96 | struct md_capainfo *md_capainfo(const struct lu_env *env); | |
97 | struct md_quota *md_quota(const struct lu_env *env); | |
98 | ||
99 | /** metadata attributes */ | |
100 | enum ma_valid { | |
101 | MA_INODE = (1 << 0), | |
102 | MA_LOV = (1 << 1), | |
103 | MA_COOKIE = (1 << 2), | |
104 | MA_FLAGS = (1 << 3), | |
105 | MA_LMV = (1 << 4), | |
106 | MA_ACL_DEF = (1 << 5), | |
107 | MA_LOV_DEF = (1 << 6), | |
108 | MA_LAY_GEN = (1 << 7), | |
109 | MA_HSM = (1 << 8), | |
110 | MA_SOM = (1 << 9), | |
111 | MA_PFID = (1 << 10) | |
112 | }; | |
113 | ||
114 | typedef enum { | |
115 | MDL_MINMODE = 0, | |
116 | MDL_EX = 1, | |
117 | MDL_PW = 2, | |
118 | MDL_PR = 4, | |
119 | MDL_CW = 8, | |
120 | MDL_CR = 16, | |
121 | MDL_NL = 32, | |
122 | MDL_GROUP = 64, | |
123 | MDL_MAXMODE | |
124 | } mdl_mode_t; | |
125 | ||
126 | typedef enum { | |
127 | MDT_NUL_LOCK = 0, | |
128 | MDT_REG_LOCK = (1 << 0), | |
129 | MDT_PDO_LOCK = (1 << 1) | |
130 | } mdl_type_t; | |
131 | ||
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 | |
135 | */ | |
136 | struct md_hsm { | |
137 | __u32 mh_compat; | |
138 | __u32 mh_flags; | |
139 | __u64 mh_arch_id; | |
140 | __u64 mh_arch_ver; | |
141 | }; | |
142 | ||
143 | #define IOEPOCH_INVAL 0 | |
144 | ||
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 | |
148 | */ | |
149 | struct md_som_data { | |
150 | __u32 msd_compat; | |
151 | __u32 msd_incompat; | |
152 | __u64 msd_ioepoch; | |
153 | __u64 msd_size; | |
154 | __u64 msd_blocks; | |
155 | __u64 msd_mountid; | |
156 | }; | |
157 | ||
158 | struct md_attr { | |
159 | __u64 ma_valid; | |
160 | __u64 ma_need; | |
161 | __u64 ma_attr_flags; | |
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; | |
167 | void *ma_acl; | |
168 | struct llog_cookie *ma_cookie; | |
169 | struct lustre_capa *ma_capa; | |
170 | struct md_som_data *ma_som; | |
171 | int ma_lmm_size; | |
172 | int ma_lmv_size; | |
173 | int ma_acl_size; | |
174 | int ma_cookie_size; | |
175 | __u16 ma_layout_gen; | |
176 | }; | |
177 | ||
178 | /** Additional parameters for create */ | |
179 | struct md_op_spec { | |
180 | union { | |
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 */ | |
186 | struct md_spec_reg { | |
187 | /** lov objs exist already */ | |
188 | const struct lu_fid *fid; | |
189 | const void *eadata; | |
190 | int eadatalen; | |
191 | } sp_ea; | |
192 | } u; | |
193 | ||
194 | /** Create flag from client: such as MDS_OPEN_CREAT, and others. */ | |
195 | __u64 sp_cr_flags; | |
196 | ||
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 */ | |
201 | ||
202 | /** Current lock mode for parent dir where create is performing. */ | |
203 | mdl_mode_t sp_cr_mode; | |
204 | ||
205 | /** to create directory */ | |
206 | const struct dt_index_features *sp_feat; | |
207 | }; | |
208 | ||
209 | /** | |
210 | * Operations implemented for each md object (both directory and leaf). | |
211 | */ | |
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); | |
216 | ||
217 | int (*moo_attr_get)(const struct lu_env *env, struct md_object *obj, | |
218 | struct md_attr *attr); | |
219 | ||
220 | int (*moo_attr_set)(const struct lu_env *env, struct md_object *obj, | |
221 | const struct md_attr *attr); | |
222 | ||
223 | int (*moo_xattr_get)(const struct lu_env *env, struct md_object *obj, | |
224 | struct lu_buf *buf, const char *name); | |
225 | ||
226 | int (*moo_xattr_list)(const struct lu_env *env, struct md_object *obj, | |
227 | struct lu_buf *buf); | |
228 | ||
229 | int (*moo_xattr_set)(const struct lu_env *env, struct md_object *obj, | |
230 | const struct lu_buf *buf, const char *name, | |
231 | int fl); | |
232 | ||
233 | int (*moo_xattr_del)(const struct lu_env *env, struct md_object *obj, | |
234 | const char *name); | |
235 | ||
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, | |
239 | __u64 flags); | |
240 | ||
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); | |
244 | ||
245 | int (*moo_readlink)(const struct lu_env *env, struct md_object *obj, | |
246 | struct lu_buf *buf); | |
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, | |
254 | struct md_attr *ma); | |
255 | ||
256 | int (*moo_ref_add)(const struct lu_env *env, | |
257 | struct md_object *obj, | |
258 | const struct md_attr *ma); | |
259 | ||
260 | int (*moo_ref_del)(const struct lu_env *env, | |
261 | struct md_object *obj, | |
262 | struct md_attr *ma); | |
263 | ||
264 | int (*moo_open)(const struct lu_env *env, | |
265 | struct md_object *obj, int flag); | |
266 | ||
267 | int (*moo_close)(const struct lu_env *env, struct md_object *obj, | |
268 | struct md_attr *ma, int mode); | |
269 | ||
270 | int (*moo_capa_get)(const struct lu_env *, struct md_object *, | |
271 | struct lustre_capa *, int renewal); | |
272 | ||
273 | int (*moo_object_sync)(const struct lu_env *, struct md_object *); | |
274 | ||
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, | |
284 | void *policy); | |
285 | }; | |
286 | ||
287 | /** | |
288 | * Operations implemented for each directory object. | |
289 | */ | |
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); | |
293 | ||
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); | |
297 | ||
298 | mdl_mode_t (*mdo_lock_mode)(const struct lu_env *env, | |
299 | struct md_object *obj, | |
300 | mdl_mode_t mode); | |
301 | ||
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, | |
305 | struct md_attr *ma); | |
306 | ||
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, | |
309 | struct md_object *o, | |
310 | const struct md_op_spec *spec, | |
311 | struct md_attr *ma); | |
312 | ||
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); | |
317 | ||
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, | |
320 | struct md_attr *ma); | |
321 | ||
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); | |
325 | ||
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, | |
331 | struct md_attr *ma); | |
332 | ||
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); | |
339 | ||
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); | |
344 | ||
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); | |
348 | }; | |
349 | ||
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, | |
353 | struct lu_fid *f); | |
354 | ||
7fc1f831 AP |
355 | int (*mdo_maxeasize_get)(const struct lu_env *env, struct md_device *m, |
356 | int *easize); | |
d7e09d03 PT |
357 | |
358 | int (*mdo_statfs)(const struct lu_env *env, struct md_device *m, | |
359 | struct obd_statfs *sfs); | |
360 | ||
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); | |
364 | ||
365 | int (*mdo_update_capa_key)(const struct lu_env *env, | |
366 | struct md_device *m, | |
367 | struct lustre_capa_key *key); | |
368 | ||
369 | int (*mdo_llog_ctxt_get)(const struct lu_env *env, | |
370 | struct md_device *m, int idx, void **h); | |
371 | ||
372 | int (*mdo_iocontrol)(const struct lu_env *env, struct md_device *m, | |
373 | unsigned int cmd, int len, void *data); | |
374 | }; | |
375 | ||
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) | |
384 | }; | |
385 | ||
386 | struct md_upcall { | |
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); | |
395 | }; | |
396 | ||
397 | struct md_device { | |
398 | struct lu_device md_lu_dev; | |
399 | const struct md_device_operations *md_ops; | |
400 | struct md_upcall md_upcall; | |
401 | }; | |
402 | ||
403 | static inline void md_upcall_init(struct md_device *m, void *upcl) | |
404 | { | |
405 | init_rwsem(&m->md_upcall.mu_upcall_sem); | |
406 | m->md_upcall.mu_upcall_dev = NULL; | |
407 | m->md_upcall.mu_upcall = upcl; | |
408 | } | |
409 | ||
410 | static inline void md_upcall_dev_set(struct md_device *m, struct md_device *up) | |
411 | { | |
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); | |
415 | } | |
416 | ||
417 | static inline void md_upcall_fini(struct md_device *m) | |
418 | { | |
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); | |
423 | } | |
424 | ||
425 | static inline int md_do_upcall(const struct lu_env *env, struct md_device *m, | |
426 | enum md_upcall_event ev, void *data) | |
427 | { | |
428 | int rc = 0; | |
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, | |
434 | ev, data); | |
435 | } | |
436 | up_read(&m->md_upcall.mu_upcall_sem); | |
437 | return rc; | |
438 | } | |
439 | ||
440 | struct md_object { | |
441 | struct lu_object mo_lu; | |
442 | const struct md_object_operations *mo_ops; | |
443 | const struct md_dir_operations *mo_dir_ops; | |
444 | }; | |
445 | ||
446 | /** | |
447 | * seq-server site. | |
448 | */ | |
449 | struct seq_server_site { | |
450 | struct lu_site *ss_lu; | |
451 | /** | |
452 | * mds number of this site. | |
453 | */ | |
114acca8 | 454 | u32 ss_node_id; |
d7e09d03 PT |
455 | /** |
456 | * Fid location database | |
457 | */ | |
458 | struct lu_server_fld *ss_server_fld; | |
459 | struct lu_client_fld *ss_client_fld; | |
460 | ||
461 | /** | |
462 | * Server Seq Manager | |
463 | */ | |
464 | struct lu_server_seq *ss_server_seq; | |
465 | ||
466 | /** | |
467 | * Controller Seq Manager | |
468 | */ | |
469 | struct lu_server_seq *ss_control_seq; | |
470 | struct obd_export *ss_control_exp; | |
471 | ||
472 | /** | |
473 | * Client Seq Manager | |
474 | */ | |
475 | struct lu_client_seq *ss_client_seq; | |
476 | }; | |
477 | ||
478 | static inline struct md_device *lu2md_dev(const struct lu_device *d) | |
479 | { | |
480 | LASSERT(IS_ERR(d) || lu_device_is_md(d)); | |
481 | return container_of0(d, struct md_device, md_lu_dev); | |
482 | } | |
483 | ||
484 | static inline struct lu_device *md2lu_dev(struct md_device *d) | |
485 | { | |
486 | return &d->md_lu_dev; | |
487 | } | |
488 | ||
489 | static inline struct md_object *lu2md(const struct lu_object *o) | |
490 | { | |
491 | LASSERT(o == NULL || IS_ERR(o) || lu_device_is_md(o->lo_dev)); | |
492 | return container_of0(o, struct md_object, mo_lu); | |
493 | } | |
494 | ||
495 | static inline struct md_object *md_object_next(const struct md_object *obj) | |
496 | { | |
497 | return (obj ? lu2md(lu_object_next(&obj->mo_lu)) : NULL); | |
498 | } | |
499 | ||
500 | static inline struct md_device *md_obj2dev(const struct md_object *o) | |
501 | { | |
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); | |
504 | } | |
505 | ||
d7e09d03 PT |
506 | static inline int md_device_init(struct md_device *md, struct lu_device_type *t) |
507 | { | |
508 | return lu_device_init(&md->md_lu_dev, t); | |
509 | } | |
510 | ||
511 | static inline void md_device_fini(struct md_device *md) | |
512 | { | |
513 | lu_device_fini(&md->md_lu_dev); | |
514 | } | |
515 | ||
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) | |
519 | { | |
520 | return lu2md(lu_object_find_slice(env, md2lu_dev(md), f, NULL)); | |
521 | } | |
522 | ||
523 | ||
524 | /** md operations */ | |
525 | static inline int mo_permission(const struct lu_env *env, | |
526 | struct md_object *p, | |
527 | struct md_object *c, | |
528 | struct md_attr *at, | |
529 | int mask) | |
530 | { | |
531 | LASSERT(c->mo_ops->moo_permission); | |
532 | return c->mo_ops->moo_permission(env, p, c, at, mask); | |
533 | } | |
534 | ||
535 | static inline int mo_attr_get(const struct lu_env *env, | |
536 | struct md_object *m, | |
537 | struct md_attr *at) | |
538 | { | |
539 | LASSERT(m->mo_ops->moo_attr_get); | |
540 | return m->mo_ops->moo_attr_get(env, m, at); | |
541 | } | |
542 | ||
543 | static inline int mo_readlink(const struct lu_env *env, | |
544 | struct md_object *m, | |
545 | struct lu_buf *buf) | |
546 | { | |
547 | LASSERT(m->mo_ops->moo_readlink); | |
548 | return m->mo_ops->moo_readlink(env, m, buf); | |
549 | } | |
550 | ||
551 | static inline int mo_changelog(const struct lu_env *env, | |
552 | enum changelog_rec_type type, | |
553 | int flags, struct md_object *m) | |
554 | { | |
555 | LASSERT(m->mo_ops->moo_changelog); | |
556 | return m->mo_ops->moo_changelog(env, type, flags, m); | |
557 | } | |
558 | ||
559 | static inline int mo_attr_set(const struct lu_env *env, | |
560 | struct md_object *m, | |
561 | const struct md_attr *at) | |
562 | { | |
563 | LASSERT(m->mo_ops->moo_attr_set); | |
564 | return m->mo_ops->moo_attr_set(env, m, at); | |
565 | } | |
566 | ||
567 | static inline int mo_xattr_get(const struct lu_env *env, | |
568 | struct md_object *m, | |
569 | struct lu_buf *buf, | |
570 | const char *name) | |
571 | { | |
572 | LASSERT(m->mo_ops->moo_xattr_get); | |
573 | return m->mo_ops->moo_xattr_get(env, m, buf, name); | |
574 | } | |
575 | ||
576 | static inline int mo_xattr_del(const struct lu_env *env, | |
577 | struct md_object *m, | |
578 | const char *name) | |
579 | { | |
580 | LASSERT(m->mo_ops->moo_xattr_del); | |
581 | return m->mo_ops->moo_xattr_del(env, m, name); | |
582 | } | |
583 | ||
584 | static inline int mo_xattr_set(const struct lu_env *env, | |
585 | struct md_object *m, | |
586 | const struct lu_buf *buf, | |
587 | const char *name, | |
588 | int flags) | |
589 | { | |
590 | LASSERT(m->mo_ops->moo_xattr_set); | |
591 | return m->mo_ops->moo_xattr_set(env, m, buf, name, flags); | |
592 | } | |
593 | ||
594 | static inline int mo_xattr_list(const struct lu_env *env, | |
595 | struct md_object *m, | |
596 | struct lu_buf *buf) | |
597 | { | |
598 | LASSERT(m->mo_ops->moo_xattr_list); | |
599 | return m->mo_ops->moo_xattr_list(env, m, buf); | |
600 | } | |
601 | ||
602 | static inline int mo_swap_layouts(const struct lu_env *env, | |
603 | struct md_object *o1, | |
604 | struct md_object *o2, __u64 flags) | |
605 | { | |
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) | |
609 | return -EPERM; | |
610 | return o1->mo_ops->moo_swap_layouts(env, o1, o2, flags); | |
611 | } | |
612 | ||
613 | static inline int mo_open(const struct lu_env *env, | |
614 | struct md_object *m, | |
615 | int flags) | |
616 | { | |
617 | LASSERT(m->mo_ops->moo_open); | |
618 | return m->mo_ops->moo_open(env, m, flags); | |
619 | } | |
620 | ||
621 | static inline int mo_close(const struct lu_env *env, | |
622 | struct md_object *m, | |
623 | struct md_attr *ma, | |
624 | int mode) | |
625 | { | |
626 | LASSERT(m->mo_ops->moo_close); | |
627 | return m->mo_ops->moo_close(env, m, ma, mode); | |
628 | } | |
629 | ||
630 | static inline int mo_readpage(const struct lu_env *env, | |
631 | struct md_object *m, | |
632 | const struct lu_rdpg *rdpg) | |
633 | { | |
634 | LASSERT(m->mo_ops->moo_readpage); | |
635 | return m->mo_ops->moo_readpage(env, m, rdpg); | |
636 | } | |
637 | ||
638 | static inline int mo_object_create(const struct lu_env *env, | |
639 | struct md_object *m, | |
640 | const struct md_op_spec *spc, | |
641 | struct md_attr *at) | |
642 | { | |
643 | LASSERT(m->mo_ops->moo_object_create); | |
644 | return m->mo_ops->moo_object_create(env, m, spc, at); | |
645 | } | |
646 | ||
647 | static inline int mo_ref_add(const struct lu_env *env, | |
648 | struct md_object *m, | |
649 | const struct md_attr *ma) | |
650 | { | |
651 | LASSERT(m->mo_ops->moo_ref_add); | |
652 | return m->mo_ops->moo_ref_add(env, m, ma); | |
653 | } | |
654 | ||
655 | static inline int mo_ref_del(const struct lu_env *env, | |
656 | struct md_object *m, | |
657 | struct md_attr *ma) | |
658 | { | |
659 | LASSERT(m->mo_ops->moo_ref_del); | |
660 | return m->mo_ops->moo_ref_del(env, m, ma); | |
661 | } | |
662 | ||
663 | static inline int mo_capa_get(const struct lu_env *env, | |
664 | struct md_object *m, | |
665 | struct lustre_capa *c, | |
666 | int renewal) | |
667 | { | |
668 | LASSERT(m->mo_ops->moo_capa_get); | |
669 | return m->mo_ops->moo_capa_get(env, m, c, renewal); | |
670 | } | |
671 | ||
672 | static inline int mo_object_sync(const struct lu_env *env, struct md_object *m) | |
673 | { | |
674 | LASSERT(m->mo_ops->moo_object_sync); | |
675 | return m->mo_ops->moo_object_sync(env, m); | |
676 | } | |
677 | ||
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) | |
682 | { | |
683 | LASSERT(m->mo_ops->moo_file_lock); | |
684 | return m->mo_ops->moo_file_lock(env, m, lmm, extent, lockh); | |
685 | } | |
686 | ||
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) | |
690 | { | |
691 | LASSERT(m->mo_ops->moo_file_unlock); | |
692 | return m->mo_ops->moo_file_unlock(env, m, lmm, lockh); | |
693 | } | |
694 | ||
695 | static inline int mo_object_lock(const struct lu_env *env, | |
696 | struct md_object *m, | |
697 | struct lustre_handle *lh, | |
698 | struct ldlm_enqueue_info *einfo, | |
699 | void *policy) | |
700 | { | |
701 | LASSERT(m->mo_ops->moo_object_lock); | |
702 | return m->mo_ops->moo_object_lock(env, m, lh, einfo, policy); | |
703 | } | |
704 | ||
705 | static inline int mdo_lookup(const struct lu_env *env, | |
706 | struct md_object *p, | |
707 | const struct lu_name *lname, | |
708 | struct lu_fid *f, | |
709 | struct md_op_spec *spec) | |
710 | { | |
711 | LASSERT(p->mo_dir_ops->mdo_lookup); | |
712 | return p->mo_dir_ops->mdo_lookup(env, p, lname, f, spec); | |
713 | } | |
714 | ||
715 | static inline mdl_mode_t mdo_lock_mode(const struct lu_env *env, | |
716 | struct md_object *mo, | |
717 | mdl_mode_t lm) | |
718 | { | |
719 | if (mo->mo_dir_ops->mdo_lock_mode == NULL) | |
720 | return MDL_MINMODE; | |
721 | return mo->mo_dir_ops->mdo_lock_mode(env, mo, lm); | |
722 | } | |
723 | ||
724 | static inline int mdo_create(const struct lu_env *env, | |
725 | struct md_object *p, | |
726 | const struct lu_name *lchild_name, | |
727 | struct md_object *c, | |
728 | struct md_op_spec *spc, | |
729 | struct md_attr *at) | |
730 | { | |
731 | LASSERT(p->mo_dir_ops->mdo_create); | |
732 | return p->mo_dir_ops->mdo_create(env, p, lchild_name, c, spc, at); | |
733 | } | |
734 | ||
735 | static inline int mdo_create_data(const struct lu_env *env, | |
736 | struct md_object *p, | |
737 | struct md_object *c, | |
738 | const struct md_op_spec *spec, | |
739 | struct md_attr *ma) | |
740 | { | |
741 | LASSERT(c->mo_dir_ops->mdo_create_data); | |
742 | return c->mo_dir_ops->mdo_create_data(env, p, c, spec, ma); | |
743 | } | |
744 | ||
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, | |
750 | struct md_object *t, | |
751 | const struct lu_name *ltname, | |
752 | struct md_attr *ma) | |
753 | { | |
754 | LASSERT(tp->mo_dir_ops->mdo_rename); | |
755 | return tp->mo_dir_ops->mdo_rename(env, sp, tp, lf, lsname, t, ltname, | |
756 | ma); | |
757 | } | |
758 | ||
759 | static inline int mdo_is_subdir(const struct lu_env *env, | |
760 | struct md_object *mo, | |
761 | const struct lu_fid *fid, | |
762 | struct lu_fid *sfid) | |
763 | { | |
764 | LASSERT(mo->mo_dir_ops->mdo_is_subdir); | |
765 | return mo->mo_dir_ops->mdo_is_subdir(env, mo, fid, sfid); | |
766 | } | |
767 | ||
768 | static inline int mdo_link(const struct lu_env *env, | |
769 | struct md_object *p, | |
770 | struct md_object *s, | |
771 | const struct lu_name *lname, | |
772 | struct md_attr *ma) | |
773 | { | |
774 | LASSERT(s->mo_dir_ops->mdo_link); | |
775 | return s->mo_dir_ops->mdo_link(env, p, s, lname, ma); | |
776 | } | |
777 | ||
778 | static inline int mdo_unlink(const struct lu_env *env, | |
779 | struct md_object *p, | |
780 | struct md_object *c, | |
781 | const struct lu_name *lname, | |
782 | struct md_attr *ma, int no_name) | |
783 | { | |
784 | LASSERT(p->mo_dir_ops->mdo_unlink); | |
785 | return p->mo_dir_ops->mdo_unlink(env, p, c, lname, ma, no_name); | |
786 | } | |
787 | ||
788 | static inline int mdo_lum_lmm_cmp(const struct lu_env *env, | |
789 | struct md_object *c, | |
790 | const struct md_op_spec *spec, | |
791 | struct md_attr *ma) | |
792 | { | |
793 | LASSERT(c->mo_dir_ops->mdo_lum_lmm_cmp); | |
794 | return c->mo_dir_ops->mdo_lum_lmm_cmp(env, c, spec, ma); | |
795 | } | |
796 | ||
797 | static inline int mdo_name_insert(const struct lu_env *env, | |
798 | struct md_object *p, | |
799 | const struct lu_name *lname, | |
800 | const struct lu_fid *f, | |
801 | const struct md_attr *ma) | |
802 | { | |
803 | LASSERT(p->mo_dir_ops->mdo_name_insert); | |
804 | return p->mo_dir_ops->mdo_name_insert(env, p, lname, f, ma); | |
805 | } | |
806 | ||
807 | static inline int mdo_name_remove(const struct lu_env *env, | |
808 | struct md_object *p, | |
809 | const struct lu_name *lname, | |
810 | const struct md_attr *ma) | |
811 | { | |
812 | LASSERT(p->mo_dir_ops->mdo_name_remove); | |
813 | return p->mo_dir_ops->mdo_name_remove(env, p, lname, ma); | |
814 | } | |
815 | ||
816 | static inline int mdo_rename_tgt(const struct lu_env *env, | |
817 | struct md_object *p, | |
818 | struct md_object *t, | |
819 | const struct lu_fid *lf, | |
820 | const struct lu_name *lname, | |
821 | struct md_attr *ma) | |
822 | { | |
823 | if (t) { | |
824 | LASSERT(t->mo_dir_ops->mdo_rename_tgt); | |
825 | return t->mo_dir_ops->mdo_rename_tgt(env, p, t, lf, lname, ma); | |
826 | } else { | |
827 | LASSERT(p->mo_dir_ops->mdo_rename_tgt); | |
828 | return p->mo_dir_ops->mdo_rename_tgt(env, p, t, lf, lname, ma); | |
829 | } | |
830 | } | |
831 | ||
832 | /** | |
833 | * Used in MDD/OUT layer for object lock rule | |
834 | **/ | |
835 | enum mdd_object_role { | |
836 | MOR_SRC_PARENT, | |
837 | MOR_SRC_CHILD, | |
838 | MOR_TGT_PARENT, | |
839 | MOR_TGT_CHILD, | |
840 | MOR_TGT_ORPHAN | |
841 | }; | |
842 | ||
843 | struct dt_device; | |
844 | /** | |
845 | * Structure to hold object information. This is used to create object | |
846 | * \pre llod_dir exist | |
847 | */ | |
848 | struct lu_local_obj_desc { | |
849 | const char *llod_dir; | |
850 | const char *llod_name; | |
851 | __u32 llod_oid; | |
852 | int llod_is_index; | |
853 | const struct dt_index_features *llod_feat; | |
854 | struct list_head llod_linkage; | |
855 | }; | |
856 | ||
d7e09d03 PT |
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); | |
860 | ||
861 | struct lu_ucred { | |
862 | __u32 uc_valid; | |
863 | __u32 uc_o_uid; | |
864 | __u32 uc_o_gid; | |
865 | __u32 uc_o_fsuid; | |
866 | __u32 uc_o_fsgid; | |
867 | __u32 uc_uid; | |
868 | __u32 uc_gid; | |
869 | __u32 uc_fsuid; | |
870 | __u32 uc_fsgid; | |
871 | __u32 uc_suppgids[2]; | |
872 | cfs_cap_t uc_cap; | |
873 | __u32 uc_umask; | |
c88a6cbb | 874 | struct group_info *uc_ginfo; |
d7e09d03 PT |
875 | struct md_identity *uc_identity; |
876 | }; | |
877 | ||
878 | struct lu_ucred *lu_ucred(const struct lu_env *env); | |
879 | ||
880 | struct lu_ucred *lu_ucred_check(const struct lu_env *env); | |
881 | ||
882 | struct lu_ucred *lu_ucred_assert(const struct lu_env *env); | |
883 | ||
884 | int lu_ucred_global_init(void); | |
885 | ||
886 | void lu_ucred_global_fini(void); | |
887 | ||
888 | #define md_cap_t(x) (x) | |
889 | ||
890 | #define MD_CAP_TO_MASK(x) (1 << (x)) | |
891 | ||
892 | #define md_cap_raised(c, flag) (md_cap_t(c) & MD_CAP_TO_MASK(flag)) | |
893 | ||
894 | /* capable() is copied from linux kernel! */ | |
895 | static inline int md_capable(struct lu_ucred *uc, cfs_cap_t cap) | |
896 | { | |
897 | if (md_cap_raised(uc->uc_cap, cap)) | |
898 | return 1; | |
899 | return 0; | |
900 | } | |
901 | ||
902 | /** @} md */ | |
903 | #endif /* _LINUX_MD_OBJECT_H */ |