Whamcloud - gitweb
c1c5d281959abaa9d4c01d52329c19456e47f547
[fs/lustre-release.git] / lustre / include / dt_object.h
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.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2011, 2017, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  */
32
33 #ifndef __LUSTRE_DT_OBJECT_H
34 #define __LUSTRE_DT_OBJECT_H
35
36 /** \defgroup dt dt
37  * Sub-class of lu_object with methods common for "data" objects in OST stack.
38  *
39  * Data objects behave like regular files: you can read/write them, get and
40  * set their attributes. Implementation of dt interface is supposed to
41  * implement some form of garbage collection, normally reference counting
42  * (nlink) based one.
43  *
44  * Examples: osd (lustre/osd) is an implementation of dt interface.
45  * @{
46  */
47
48 #include <obd_support.h>
49 /*
50  * super-class definitions.
51  */
52 #include <lu_object.h>
53
54 #include <libcfs/libcfs.h>
55
56 struct seq_file;
57 struct proc_dir_entry;
58 struct lustre_cfg;
59
60 struct thandle;
61 struct dt_device;
62 struct dt_object;
63 struct dt_index_features;
64 struct niobuf_local;
65 struct niobuf_remote;
66 struct ldlm_enqueue_info;
67
68 typedef enum {
69         MNTOPT_USERXATTR        = 0x00000001,
70         MNTOPT_ACL              = 0x00000002,
71 } mntopt_t;
72
73 struct dt_device_param {
74         unsigned           ddp_max_name_len;
75         unsigned           ddp_max_nlink;
76         unsigned           ddp_symlink_max;
77         mntopt_t           ddp_mntopts;
78         unsigned           ddp_max_ea_size;
79         unsigned           ddp_mount_type;
80         unsigned long long ddp_maxbytes;
81         /* per-inode space consumption */
82         short              ddp_inodespace;
83         /* maximum number of blocks in an extent */
84         unsigned           ddp_max_extent_blks;
85         /* per-extent insertion overhead to be used by client for grant
86          * calculation */
87         unsigned int       ddp_extent_tax;
88         unsigned int       ddp_brw_size;        /* optimal RPC size */
89         /* T10PI checksum type, zero if not supported */
90         enum cksum_types   ddp_t10_cksum_type;
91 };
92
93 /**
94  * Per-transaction commit callback function
95  */
96 struct dt_txn_commit_cb;
97 typedef void (*dt_cb_t)(struct lu_env *env, struct thandle *th,
98                         struct dt_txn_commit_cb *cb, int err);
99 /**
100  * Special per-transaction callback for cases when just commit callback
101  * is needed and per-device callback are not convenient to use
102  */
103 #define TRANS_COMMIT_CB_MAGIC   0xa0a00a0a
104 #define MAX_COMMIT_CB_STR_LEN   32
105
106 #define DCB_TRANS_STOP          0x1
107 struct dt_txn_commit_cb {
108         struct list_head        dcb_linkage;
109         dt_cb_t                 dcb_func;
110         void                    *dcb_data;
111         __u32                   dcb_magic;
112         __u32                   dcb_flags;
113         char                    dcb_name[MAX_COMMIT_CB_STR_LEN];
114 };
115
116 /**
117  * Operations on dt device.
118  */
119 struct dt_device_operations {
120         /**
121          * Return device-wide statistics.
122          *
123          * Return device-wide stats including block size, total and
124          * free blocks, total and free objects, etc. See struct obd_statfs
125          * for the details.
126          *
127          * \param[in] env       execution environment for this thread
128          * \param[in] dev       dt device
129          * \param[out] osfs     stats information
130          *
131          * \retval 0            on success
132          * \retval negative     negated errno on error
133          */
134         int   (*dt_statfs)(const struct lu_env *env,
135                            struct dt_device *dev,
136                            struct obd_statfs *osfs,
137                            struct obd_statfs_info *info);
138
139         /**
140          * Create transaction.
141          *
142          * Create in-memory structure representing the transaction for the
143          * caller. The structure returned will be used by the calling thread
144          * to specify the transaction the updates belong to. Once created
145          * successfully ->dt_trans_stop() must be called in any case (with
146          * ->dt_trans_start() and updates or not) so that the transaction
147          * handle and other resources can be released by the layers below.
148          *
149          * \param[in] env       execution environment for this thread
150          * \param[in] dev       dt device
151          *
152          * \retval pointer to handle    if creation succeeds
153          * \retval ERR_PTR(errno)       if creation fails
154          */
155         struct thandle *(*dt_trans_create)(const struct lu_env *env,
156                                            struct dt_device *dev);
157
158         /**
159          * Start transaction.
160          *
161          * Start the transaction. The transaction described by \a th can be
162          * started only once. Another start is considered as an error.
163          * A thread is not supposed to start a transaction while another
164          * transaction isn't closed by the thread (though multiple handles
165          * can be created). The caller should start the transaction once
166          * all possible updates are declared (see the ->do_declare_* methods
167          * below) and all the needed resources are reserved.
168          *
169          * \param[in] env       execution environment for this thread
170          * \param[in] dev       dt device
171          * \param[in] th        transaction handle
172          *
173          * \retval 0            on success
174          * \retval negative     negated errno on error
175          */
176         int   (*dt_trans_start)(const struct lu_env *env,
177                                 struct dt_device *dev,
178                                 struct thandle *th);
179
180         /**
181          * Stop transaction.
182          *
183          * Once stopped the transaction described by \a th is complete (all
184          * the needed updates are applied) and further processing such as
185          * flushing to disk, sending to another target, etc, is handled by
186          * lower layers. The caller can't access this transaction by the
187          * handle anymore (except from the commit callbacks, see below).
188          *
189          * \param[in] env       execution environment for this thread
190          * \param[in] dev       dt device
191          * \param[in] th        transaction handle
192          *
193          * \retval 0            on success
194          * \retval negative     negated errno on error
195          */
196         int   (*dt_trans_stop)(const struct lu_env *env,
197                                struct dt_device *dev,
198                                struct thandle *th);
199
200         /**
201          * Add commit callback to the transaction.
202          *
203          * Add a commit callback to the given transaction handle. The callback
204          * will be called when the associated transaction is stored. I.e. the
205          * transaction will survive an event like power off if the callback did
206          * run. The number of callbacks isn't limited, but you should note that
207          * some disk filesystems do handle the commit callbacks in the thread
208          * handling commit/flush of all the transactions, meaning that new
209          * transactions are blocked from commit and flush until all the
210          * callbacks are done. Also, note multiple callbacks can be running
211          * concurrently using multiple CPU cores. The callbacks will be running
212          * in a special environment which can not be used to pass data around.
213          *
214          * \param[in] th        transaction handle
215          * \param[in] dcb       commit callback description
216          *
217          * \retval 0            on success
218          * \retval negative     negated errno on error
219          */
220         int   (*dt_trans_cb_add)(struct thandle *th,
221                                  struct dt_txn_commit_cb *dcb);
222
223         /**
224          * Return FID of root index object.
225          *
226          * Return the FID of the root object in the filesystem. This object
227          * is usually provided as a bootstrap point by a disk filesystem.
228          * This is up to the implementation which FID to use, though
229          * [FID_SEQ_ROOT:1:0] is reserved for this purpose.
230          *
231          * \param[in] env       execution environment for this thread
232          * \param[in] dev       dt device
233          * \param[out] fid      FID of the root object
234          *
235          * \retval 0            on success
236          * \retval negative     negated errno on error
237          */
238         int   (*dt_root_get)(const struct lu_env *env,
239                              struct dt_device *dev,
240                              struct lu_fid *f);
241
242         /**
243          * Return device configuration data.
244          *
245          * Return device (disk fs, actually) specific configuration.
246          * The configuration isn't subject to change at runtime.
247          * See struct dt_device_param for the details.
248          *
249          * \param[in] env       execution environment for this thread
250          * \param[in] dev       dt device
251          * \param[out] param    configuration parameters
252          */
253         void  (*dt_conf_get)(const struct lu_env *env,
254                              const struct dt_device *dev,
255                              struct dt_device_param *param);
256
257         /**
258          * Return device's super block.
259          *
260          * \param[in] dev       dt device
261          */
262         struct super_block *(*dt_mnt_sb_get)(const struct dt_device *dev);
263
264         /**
265          * Sync the device.
266          *
267          * Sync all the cached state (dirty buffers, pages, etc) to the
268          * persistent storage. The method returns control once the sync is
269          * complete. This operation may incur significant I/O to disk and
270          * should be reserved for cases where a global sync is strictly
271          * necessary.
272          *
273          * \param[in] env       execution environment for this thread
274          * \param[in] dev       dt device
275          *
276          * \retval 0            on success
277          * \retval negative     negated errno on error
278          */
279         int   (*dt_sync)(const struct lu_env *env,
280                          struct dt_device *dev);
281
282         /**
283          * Make device read-only.
284          *
285          * Prevent new modifications to the device. This is a very specific
286          * state where all the changes are accepted successfully and the
287          * commit callbacks are called, but persistent state never changes.
288          * Used only in the tests to simulate power-off scenario.
289          *
290          * \param[in] env       execution environment for this thread
291          * \param[in] dev       dt device
292          *
293          * \retval 0            on success
294          * \retval negative     negated errno on error
295          */
296         int   (*dt_ro)(const struct lu_env *env,
297                        struct dt_device *dev);
298
299         /**
300          * Start transaction commit asynchronously.
301          *
302
303          * Provide a hint to the underlying filesystem that it should start
304          * committing soon. The control returns immediately. It's up to the
305          * layer implementing the method how soon to start committing. Usually
306          * this should be throttled to some extent, otherwise the number of
307          * aggregated transaction goes too high causing performance drop.
308          *
309          * \param[in] env       execution environment for this thread
310          * \param[in] dev       dt device
311          *
312          * \retval 0            on success
313          * \retval negative     negated errno on error
314          */
315          int   (*dt_commit_async)(const struct lu_env *env,
316                                   struct dt_device *dev);
317 };
318
319 struct dt_index_features {
320         /** required feature flags from enum dt_index_flags */
321         __u32 dif_flags;
322         /** minimal required key size */
323         size_t dif_keysize_min;
324         /** maximal required key size, 0 if no limit */
325         size_t dif_keysize_max;
326         /** minimal required record size */
327         size_t dif_recsize_min;
328         /** maximal required record size, 0 if no limit */
329         size_t dif_recsize_max;
330         /** pointer size for record */
331         size_t dif_ptrsize;
332 };
333
334 enum dt_index_flags {
335         /** index supports variable sized keys */
336         DT_IND_VARKEY = BIT(0),
337         /** index supports variable sized records */
338         DT_IND_VARREC = BIT(1),
339         /** index can be modified */
340         DT_IND_UPDATE = BIT(2),
341         /** index supports records with non-unique (duplicate) keys */
342         DT_IND_NONUNQ = BIT(3),
343         /**
344          * index support fixed-size keys sorted with natural numerical way
345          * and is able to return left-side value if no exact value found
346          */
347         DT_IND_RANGE = BIT(4),
348 };
349
350 /* for dt_read_lock() and dt_write_lock() object lock rule */
351 enum dt_object_role {
352         DT_SRC_PARENT,
353         DT_SRC_CHILD,
354         DT_TGT_PARENT,
355         DT_TGT_CHILD,
356         DT_TGT_ORPHAN,
357         DT_LASTID,
358 };
359
360 /**
361  * Features, required from index to support file system directories (mapping
362  * names to fids).
363  */
364 extern const struct dt_index_features dt_directory_features;
365 extern const struct dt_index_features dt_otable_features;
366 extern const struct dt_index_features dt_lfsck_layout_orphan_features;
367 extern const struct dt_index_features dt_lfsck_layout_dangling_features;
368 extern const struct dt_index_features dt_lfsck_namespace_features;
369
370 /* index features supported by the accounting objects */
371 extern const struct dt_index_features dt_acct_features;
372
373 /* index features supported by the quota global indexes */
374 extern const struct dt_index_features dt_quota_glb_features;
375
376 /* index features supported by the quota slave indexes */
377 extern const struct dt_index_features dt_quota_slv_features;
378
379 /* index features supported by the nodemap index */
380 extern const struct dt_index_features dt_nodemap_features;
381
382 /**
383  * This is a general purpose dt allocation hint.
384  * It now contains the parent object.
385  * It can contain any allocation hint in the future.
386  */
387 struct dt_allocation_hint {
388         struct dt_object        *dah_parent;
389         const void              *dah_eadata;
390         int                     dah_eadata_len;
391         __u32                   dah_mode;
392         int                     dah_append_stripes;
393         char                    *dah_append_pool;
394 };
395
396 /**
397  * object type specifier.
398  */
399
400 enum dt_format_type {
401         DFT_REGULAR,
402         DFT_DIR,
403         /** for mknod */
404         DFT_NODE,
405         /** for special index */
406         DFT_INDEX,
407         /** for symbolic link */
408         DFT_SYM,
409 };
410
411 /**
412  * object format specifier.
413  */
414 struct dt_object_format {
415         /** type for dt object */
416         enum dt_format_type dof_type;
417         union {
418                 struct dof_regular {
419                         int striped;
420                 } dof_reg;
421                 struct dof_dir {
422                 } dof_dir;
423                 struct dof_node {
424                 } dof_node;
425                 /**
426                  * special index need feature as parameter to create
427                  * special idx
428                  */
429                 struct dof_index {
430                         const struct dt_index_features *di_feat;
431                 } dof_idx;
432         } u;
433 };
434
435 enum dt_format_type dt_mode_to_dft(__u32 mode);
436
437 typedef __u64 dt_obj_version_t;
438
439 union ldlm_policy_data;
440
441 struct md_layout_change;
442
443 /**
444  * A dt_object provides common operations to create and destroy
445  * objects and to manage regular and extended attributes.
446  */
447 struct dt_object_operations {
448         /**
449          * Get read lock on object.
450          *
451          * Read lock is compatible with other read locks, so it's shared.
452          * Read lock is not compatible with write lock which is exclusive.
453          * The lock is blocking and can't be used from an interrupt context.
454          *
455          * \param[in] env       execution environment for this thread
456          * \param[in] dt        object to lock for reading
457          * \param[in] role      a hint to debug locks (see kernel's mutexes)
458          */
459         void  (*do_read_lock)(const struct lu_env *env,
460                               struct dt_object *dt,
461                               unsigned role);
462
463         /*
464          * Get write lock on object.
465          *
466          * Write lock is exclusive and cannot be shared. The lock is blocking
467          * and can't be used from an interrupt context.
468          *
469          * \param[in] env       execution environment for this thread
470          * \param[in] dt        object to lock for writing
471          * \param[in] role      a hint to debug locks (see kernel's mutexes)
472          *
473          */
474         void  (*do_write_lock)(const struct lu_env *env,
475                                struct dt_object *dt,
476                                unsigned role);
477
478         /**
479          * Release read lock.
480          *
481          * \param[in] env       execution environment for this thread
482          * \param[in] dt        object
483          */
484         void  (*do_read_unlock)(const struct lu_env *env,
485                                 struct dt_object *dt);
486
487         /**
488          * Release write lock.
489          *
490          * \param[in] env       execution environment for this thread
491          * \param[in] dt        object
492          */
493         void  (*do_write_unlock)(const struct lu_env *env,
494                                  struct dt_object *dt);
495
496         /**
497          * Check whether write lock is held.
498          *
499          * The caller can learn whether write lock is held on the object
500          *
501          * \param[in] env       execution environment for this thread
502          * \param[in] dt        object
503          *
504          * \retval 0            no write lock
505          * \retval 1            write lock is held
506          */
507         int  (*do_write_locked)(const struct lu_env *env,
508                                 struct dt_object *dt);
509
510         /**
511          * Declare intention to request reqular attributes.
512          *
513          * Notity the underlying filesystem that the caller may request regular
514          * attributes with ->do_attr_get() soon. This allows OSD to implement
515          * prefetching logic in an object-oriented manner. The implementation
516          * can be noop. This method should avoid expensive delays such as
517          * waiting on disk I/O, otherwise the goal of enabling a performance
518          * optimization would be defeated.
519          *
520          * \param[in] env       execution environment for this thread
521          * \param[in] dt        object
522          *
523          * \retval 0            on success
524          * \retval negative     negated errno on error
525          */
526         int   (*do_declare_attr_get)(const struct lu_env *env,
527                                      struct dt_object *dt);
528
529         /**
530          * Return regular attributes.
531          *
532          * The object must exist. Currently all the attributes should be
533          * returned, but in the future this can be improved so that only
534          * a selected set is returned. This can improve performance as in
535          * some cases attributes are stored in different places and
536          * getting them all can be an iterative and expensive process.
537          *
538          * \param[in] env       execution environment for this thread
539          * \param[in] dt        object
540          * \param[out] attr     attributes to fill
541          *
542          * \retval 0            on success
543          * \retval negative     negated errno on error
544          */
545         int   (*do_attr_get)(const struct lu_env *env,
546                              struct dt_object *dt,
547                              struct lu_attr *attr);
548
549         /**
550          * Declare intention to change regular object's attributes.
551          *
552          * Notify the underlying filesystem that the regular attributes may
553          * change in this transaction. This enables the layer below to prepare
554          * resources (e.g. journal credits in ext4).  This method should be
555          * called between creating the transaction and starting it. Note that
556          * the la_valid field of \a attr specifies which attributes will change.
557          * The object need not exist.
558          *
559          * \param[in] env       execution environment for this thread
560          * \param[in] dt        object
561          * \param[in] attr      attributes to change specified in attr.la_valid
562          * \param[in] th        transaction handle
563          *
564          * \retval 0            on success
565          * \retval negative     negated errno on error
566          */
567         int   (*do_declare_attr_set)(const struct lu_env *env,
568                                      struct dt_object *dt,
569                                      const struct lu_attr *attr,
570                                      struct thandle *th);
571
572         /**
573          * Change regular attributes.
574          *
575          * Change regular attributes in the given transaction. Note only
576          * attributes flagged by attr.la_valid change. The object must
577          * exist. If the layer implementing this method is responsible for
578          * quota, then the method should maintain object accounting for the
579          * given credentials when la_uid/la_gid changes.
580          *
581          * \param[in] env       execution environment for this thread
582          * \param[in] dt        object
583          * \param[in] attr      new attributes to apply
584          * \param[in] th        transaction handle
585          *
586          * \retval 0            on success
587          * \retval negative     negated errno on error
588          */
589         int   (*do_attr_set)(const struct lu_env *env,
590                              struct dt_object *dt,
591                              const struct lu_attr *attr,
592                              struct thandle *th);
593
594         /**
595          * Declare intention to request extented attribute.
596          *
597          * Notify the underlying filesystem that the caller may request extended
598          * attribute with ->do_xattr_get() soon. This allows OSD to implement
599          * prefetching logic in an object-oriented manner. The implementation
600          * can be noop. This method should avoid expensive delays such as
601          * waiting on disk I/O, otherwise the goal of enabling a performance
602          * optimization would be defeated.
603          *
604          * \param[in] env       execution environment for this thread
605          * \param[in] dt        object
606          * \param[in] buf       unused, may be removed in the future
607          * \param[in] name      name of the extended attribute
608          *
609          * \retval 0            on success
610          * \retval negative     negated errno on error
611          */
612         int   (*do_declare_xattr_get)(const struct lu_env *env,
613                                       struct dt_object *dt,
614                                       struct lu_buf *buf,
615                                       const char *name);
616
617         /**
618          * Return a value of an extended attribute.
619          *
620          * The object must exist. If the buffer is NULL, then the method
621          * must return the size of the value.
622          *
623          * \param[in] env       execution environment for this thread
624          * \param[in] dt        object
625          * \param[out] buf      buffer in which to store the value
626          * \param[in] name      name of the extended attribute
627          *
628          * \retval 0            on success
629          * \retval -ERANGE      if \a buf is too small
630          * \retval negative     negated errno on error
631          * \retval positive     value's size if \a buf is NULL or has zero size
632          */
633         int   (*do_xattr_get)(const struct lu_env *env,
634                               struct dt_object *dt,
635                               struct lu_buf *buf,
636                               const char *name);
637
638         /**
639          * Declare intention to change an extended attribute.
640          *
641          * Notify the underlying filesystem that the extended attribute may
642          * change in this transaction.  This enables the layer below to prepare
643          * resources (e.g. journal credits in ext4).  This method should be
644          * called between creating the transaction and starting it. The object
645          * need not exist.
646          *
647          * \param[in] env       execution environment for this thread
648          * \param[in] dt        object
649          * \param[in] buf       buffer storing new value of the attribute
650          * \param[in] name      name of the attribute
651          * \param[in] fl        LU_XATTR_CREATE - fail if EA exists
652          *                      LU_XATTR_REPLACE - fail if EA doesn't exist
653          * \param[in] th        transaction handle
654          *
655          * \retval 0            on success
656          * \retval negative     negated errno on error
657          */
658         int   (*do_declare_xattr_set)(const struct lu_env *env,
659                                       struct dt_object *dt,
660                                       const struct lu_buf *buf,
661                                       const char *name,
662                                       int fl,
663                                       struct thandle *th);
664
665         /**
666          * Set an extended attribute.
667          *
668          * Change or replace the specified extended attribute (EA).
669          * The flags passed in \a fl dictate whether the EA is to be
670          * created or replaced, as follows.
671          *   LU_XATTR_CREATE - fail if EA exists
672          *   LU_XATTR_REPLACE - fail if EA doesn't exist
673          * The object must exist.
674          *
675          * \param[in] env       execution environment for this thread
676          * \param[in] dt        object
677          * \param[in] buf       buffer storing new value of the attribute
678          * \param[in] name      name of the attribute
679          * \param[in] fl        flags indicating EA creation or replacement
680          * \param[in] th        transaction handle
681          *
682          * \retval 0            on success
683          * \retval negative     negated errno on error
684          */
685         int   (*do_xattr_set)(const struct lu_env *env,
686                               struct dt_object *dt,
687                               const struct lu_buf *buf,
688                               const char *name,
689                               int fl,
690                               struct thandle *th);
691
692         /**
693          * Declare intention to delete an extended attribute.
694          *
695          * Notify the underlying filesystem that the extended attribute may
696          * be deleted in this transaction. This enables the layer below to
697          * prepare resources (e.g. journal credits in ext4).  This method
698          * should be called between creating the transaction and starting it.
699          * The object need not exist.
700          *
701          * \param[in] env       execution environment for this thread
702          * \param[in] dt        object
703          * \param[in] name      name of the attribute
704          * \param[in] th        transaction handle
705          *
706          * \retval 0            on success
707          * \retval negative     negated errno on error
708          */
709         int   (*do_declare_xattr_del)(const struct lu_env *env,
710                                       struct dt_object *dt,
711                                       const char *name,
712                                       struct thandle *th);
713
714         /**
715          * Delete an extended attribute.
716          *
717          * This method deletes the specified extended attribute. The object
718          * must exist.
719          *
720          * \param[in] env       execution environment for this thread
721          * \param[in] dt        object
722          * \param[in] name      name of the attribute
723          * \param[in] th        transaction handle
724          *
725          * \retval 0            on success
726          * \retval negative     negated errno on error
727          */
728         int   (*do_xattr_del)(const struct lu_env *env,
729                               struct dt_object *dt,
730                               const char *name,
731                               struct thandle *th);
732
733         /**
734          * Return a list of the extended attributes.
735          *
736          * Fills the passed buffer with a list of the extended attributes
737          * found in the object. The names are separated with '\0'.
738          * The object must exist.
739          *
740          * \param[in] env       execution environment for this thread
741          * \param[in] dt        object
742          * \param[out] buf      buffer to put the list in
743          *
744          * \retval positive     bytes used/required in the buffer
745          * \retval negative     negated errno on error
746          */
747         int   (*do_xattr_list)(const struct lu_env *env,
748                                struct dt_object *dt,
749                                const struct lu_buf *buf);
750
751         /**
752          * Prepare allocation hint for a new object.
753          *
754          * This method is used by the caller to inform OSD of the parent-child
755          * relationship between two objects and enable efficient object
756          * allocation. Filled allocation hint will be passed to ->do_create()
757          * later.
758          *
759          * \param[in] env       execution environment for this thread
760          * \param[out] ah       allocation hint
761          * \param[in] parent    parent object (can be NULL)
762          * \param[in] child     child object
763          * \param[in] _mode     type of the child object
764          */
765         void  (*do_ah_init)(const struct lu_env *env,
766                             struct dt_allocation_hint *ah,
767                             struct dt_object *parent,
768                             struct dt_object *child,
769                             umode_t mode);
770
771         /**
772          * Declare intention to create a new object.
773          *
774          * Notify the underlying filesystem that the object may be created
775          * in this transaction. This enables the layer below to prepare
776          * resources (e.g. journal credits in ext4).  This method should be
777          * called between creating the transaction and starting it.
778          *
779          * If the layer implementing this method is responsible for quota,
780          * then the method should reserve an object for the given credentials
781          * and return an error if quota is over. If object creation later
782          * fails for some reason, then the reservation should be released
783          * properly (usually in ->dt_trans_stop()).
784          *
785          * \param[in] env       execution environment for this thread
786          * \param[in] dt        object
787          * \param[in] attr      attributes of the new object
788          * \param[in] hint      allocation hint
789          * \param[in] dof       object format
790          * \param[in] th        transaction handle
791          *
792          * \retval 0            on success
793          * \retval negative     negated errno on error
794          */
795         int   (*do_declare_create)(const struct lu_env *env,
796                                    struct dt_object *dt,
797                                    struct lu_attr *attr,
798                                    struct dt_allocation_hint *hint,
799                                    struct dt_object_format *dof,
800                                    struct thandle *th);
801
802         /**
803          * Create new object.
804          *
805          * The method creates the object passed with the specified attributes
806          * and object format. Object allocation procedure can use information
807          * stored in the allocation hint. Different object formats are supported
808          * (see enum dt_format_type and struct dt_object_format) depending on
809          * the device. If creation succeeds, then LOHA_EXISTS flag must be set
810          * in the LU-object header attributes.
811          *
812          * If the layer implementing this method is responsible for quota,
813          * then the method should maintain object accounting for the given
814          * credentials.
815          *
816          * \param[in] env       execution environment for this thread
817          * \param[in] dt        object
818          * \param[in] attr      attributes of the new object
819          * \param[in] hint      allocation hint
820          * \param[in] dof       object format
821          * \param[in] th        transaction handle
822          *
823          * \retval 0            on success
824          * \retval negative     negated errno on error
825          */
826         int   (*do_create)(const struct lu_env *env,
827                            struct dt_object *dt,
828                            struct lu_attr *attr,
829                            struct dt_allocation_hint *hint,
830                            struct dt_object_format *dof,
831                            struct thandle *th);
832
833         /**
834          * Declare intention to destroy an object.
835          *
836          * Notify the underlying filesystem that the object may be destroyed
837          * in this transaction. This enables the layer below to prepare
838          * resources (e.g. journal credits in ext4).  This method should be
839          * called between creating the transaction and starting it. The object
840          * need not exist.
841          *
842          * \param[in] env       execution environment for this thread
843          * \param[in] dt        object
844          * \param[in] th        transaction handle
845          *
846          * \retval 0            on success
847          * \retval negative     negated errno on error
848          */
849         int   (*do_declare_destroy)(const struct lu_env *env,
850                                     struct dt_object *dt,
851                                     struct thandle *th);
852
853         /**
854          * Destroy an object.
855          *
856          * This method destroys the object and all the resources associated
857          * with the object (data, key/value pairs, extended attributes, etc).
858          * The object must exist. If destroy is successful, then flag
859          * LU_OBJECT_HEARD_BANSHEE should be set to forbid access to this
860          * instance of in-core object. Any subsequent access to the same FID
861          * should get another instance with no LOHA_EXIST flag set.
862          *
863          * If the layer implementing this method is responsible for quota,
864          * then the method should maintain object accounting for the given
865          * credentials.
866          *
867          * \param[in] env       execution environment for this thread
868          * \param[in] dt        object
869          * \param[in] th        transaction handle
870          *
871          * \retval 0            on success
872          * \retval negative     negated errno on error
873          */
874         int   (*do_destroy)(const struct lu_env *env,
875                             struct dt_object *dt,
876                             struct thandle *th);
877
878         /**
879          * Try object as an index.
880          *
881          * Announce that this object is going to be used as an index. This
882          * operation checks that object supports indexing operations and
883          * installs appropriate dt_index_operations vector on success.
884          * Also probes for features. Operation is successful if all required
885          * features are supported. It's not possible to access the object
886          * with index methods before ->do_index_try() returns success.
887          *
888          * \param[in] env       execution environment for this thread
889          * \param[in] dt        object
890          * \param[in] feat      index features
891          *
892          * \retval 0            on success
893          * \retval negative     negated errno on error
894          */
895         int   (*do_index_try)(const struct lu_env *env,
896                               struct dt_object *dt,
897                               const struct dt_index_features *feat);
898
899         /**
900          * Declare intention to increment nlink count.
901          *
902          * Notify the underlying filesystem that the nlink regular attribute
903          * be changed in this transaction. This enables the layer below to
904          * prepare resources (e.g. journal credits in ext4).  This method
905          * should be called between creating the transaction and starting it.
906          * The object need not exist.
907          *
908          * \param[in] env       execution environment for this thread
909          * \param[in] dt        object
910          * \param[in] th        transaction handle
911          *
912          * \retval 0            on success
913          * \retval negative     negated errno on error
914          */
915         int   (*do_declare_ref_add)(const struct lu_env *env,
916                                     struct dt_object *dt,
917                                     struct thandle *th);
918
919         /**
920          * Increment nlink.
921          *
922          * Increment nlink (from the regular attributes set) in the given
923          * transaction. Note the absolute limit for nlink should be learnt
924          * from struct dt_device_param::ddp_max_nlink. The object must exist.
925          *
926          * \param[in] env       execution environment for this thread
927          * \param[in] dt        object
928          * \param[in] th        transaction handle
929          *
930          * \retval 0            on success
931          * \retval negative     negated errno on error
932          */
933         int   (*do_ref_add)(const struct lu_env *env,
934                             struct dt_object *dt, struct thandle *th);
935
936         /**
937          * Declare intention to decrement nlink count.
938          *
939          * Notify the underlying filesystem that the nlink regular attribute
940          * be changed in this transaction. This enables the layer below to
941          * prepare resources (e.g. journal credits in ext4).  This method
942          * should be called between creating the transaction and starting it.
943          * The object need not exist.
944          *
945          * \param[in] env       execution environment for this thread
946          * \param[in] dt        object
947          * \param[in] th        transaction handle
948          *
949          * \retval 0            on success
950          * \retval negative     negated errno on error
951          */
952         int   (*do_declare_ref_del)(const struct lu_env *env,
953                                     struct dt_object *dt,
954                                     struct thandle *th);
955
956         /**
957          * Decrement nlink.
958          *
959          * Decrement nlink (from the regular attributes set) in the given
960          * transaction. The object must exist.
961          *
962          * \param[in] env       execution environment for this thread
963          * \param[in] dt        object
964          * \param[in] th        transaction handle
965          *
966          * \retval 0            on success
967          * \retval negative     negated errno on error
968          */
969         int   (*do_ref_del)(const struct lu_env *env,
970                             struct dt_object *dt,
971                             struct thandle *th);
972
973         /**
974          * Sync obect.
975          *
976          * The method is called to sync specified range of the object to a
977          * persistent storage. The control is returned once the operation is
978          * complete. The difference from ->do_sync() is that the object can
979          * be in-sync with the persistent storage (nothing to flush), then
980          * the method returns quickly with no I/O overhead. So, this method
981          * should be preferred over ->do_sync() where possible. Also note that
982          * if the object isn't clean, then some disk filesystems will call
983          * ->do_sync() to maintain overall consistency, in which case it's
984          * still very expensive.
985          *
986          * \param[in] env       execution environment for this thread
987          * \param[in] dt        object
988          * \param[in] start     start of the range to sync
989          * \param[in] end       end of the range to sync
990          *
991          * \retval 0            on success
992          * \retval negative     negated errno on error
993          */
994         int (*do_object_sync)(const struct lu_env *env, struct dt_object *obj,
995                               __u64 start, __u64 end);
996
997         /**
998          * Lock object.
999          *
1000          * Lock object(s) using Distributed Lock Manager (LDLM).
1001          *
1002          * Get LDLM locks for the object. Currently used to lock "remote"
1003          * objects in DNE configuration - a service running on MDTx needs
1004          * to lock an object on MDTy.
1005          *
1006          * \param[in] env       execution environment for this thread
1007          * \param[in] dt        object
1008          * \param[out] lh       lock handle, sometimes used, sometimes not
1009          * \param[in] einfo     ldlm callbacks, locking type and mode
1010          * \param[out] einfo    private data to be passed to unlock later
1011          * \param[in] policy    inodebits data
1012          *
1013          * \retval 0            on success
1014          * \retval negative     negated errno on error
1015          */
1016         int (*do_object_lock)(const struct lu_env *env, struct dt_object *dt,
1017                               struct lustre_handle *lh,
1018                               struct ldlm_enqueue_info *einfo,
1019                               union ldlm_policy_data *policy);
1020
1021         /**
1022          * Unlock object.
1023          *
1024          * Release LDLM lock(s) granted with ->do_object_lock().
1025          *
1026          * \param[in] env       execution environment for this thread
1027          * \param[in] dt        object
1028          * \param[in] einfo     lock handles, from ->do_object_lock()
1029          * \param[in] policy    inodebits data
1030          *
1031          * \retval 0            on success
1032          * \retval negative     negated errno on error
1033          */
1034         int (*do_object_unlock)(const struct lu_env *env,
1035                                 struct dt_object *dt,
1036                                 struct ldlm_enqueue_info *einfo,
1037                                 union ldlm_policy_data *policy);
1038
1039         /**
1040          * Invalidate attribute cache.
1041          *
1042          * This method invalidate attribute cache of the object, which is on OSP
1043          * only.
1044          *
1045          * \param[in] env       execution envionment for this thread
1046          * \param[in] dt        object
1047          *
1048          * \retval 0            on success
1049          * \retval negative     negated errno on error
1050          */
1051         int   (*do_invalidate)(const struct lu_env *env, struct dt_object *dt);
1052
1053         /**
1054          * Declare intention to instaintiate extended layout component.
1055          *
1056          * \param[in] env       execution environment
1057          * \param[in] dt        DT object
1058          * \param[in] layout    data structure to describe the changes to
1059          *                      the DT object's layout
1060          * \param[in] buf       buffer containing client's lovea or empty
1061          *
1062          * \retval 0            success
1063          * \retval -ne          error code
1064          */
1065         int (*do_declare_layout_change)(const struct lu_env *env,
1066                                         struct dt_object *dt,
1067                                         struct md_layout_change *mlc,
1068                                         struct thandle *th);
1069
1070         /**
1071          * Client is trying to write to un-instantiated layout component.
1072          *
1073          * \param[in] env       execution environment
1074          * \param[in] dt        DT object
1075          * \param[in] layout    data structure to describe the changes to
1076          *                      the DT object's layout
1077          * \param[in] buf       buffer containing client's lovea or empty
1078          *
1079          * \retval 0            success
1080          * \retval -ne          error code
1081          */
1082         int (*do_layout_change)(const struct lu_env *env, struct dt_object *dt,
1083                                 struct md_layout_change *mlc,
1084                                 struct thandle *th);
1085 };
1086
1087 enum dt_bufs_type {
1088         DT_BUFS_TYPE_READ       = 0x0000,
1089         DT_BUFS_TYPE_WRITE      = 0x0001,
1090         DT_BUFS_TYPE_READAHEAD  = 0x0002,
1091         DT_BUFS_TYPE_LOCAL      = 0x0004,
1092 };
1093
1094 /**
1095  * Per-dt-object operations on "file body" - unstructure raw data.
1096  */
1097 struct dt_body_operations {
1098         /**
1099          * Read data.
1100          *
1101          * Read unstructured data from an existing regular object.
1102          * Only data before attr.la_size is returned.
1103          *
1104          * \param[in] env       execution environment for this thread
1105          * \param[in] dt        object
1106          * \param[out] buf      buffer (including size) to copy data in
1107          * \param[in] pos       position in the object to start
1108          * \param[out] pos      original value of \a pos + bytes returned
1109          *
1110          * \retval positive     bytes read on success
1111          * \retval negative     negated errno on error
1112          */
1113         ssize_t (*dbo_read)(const struct lu_env *env,
1114                             struct dt_object *dt,
1115                             struct lu_buf *buf,
1116                             loff_t *pos);
1117
1118         /**
1119          * Declare intention to write data to object.
1120          *
1121          * Notify the underlying filesystem that data may be written in
1122          * this transaction. This enables the layer below to prepare resources
1123          * (e.g. journal credits in ext4).  This method should be called
1124          * between creating the transaction and starting it. The object need
1125          * not exist. If the layer implementing this method is responsible for
1126          * quota, then the method should reserve space for the given credentials
1127          * and return an error if quota is over. If the write later fails
1128          * for some reason, then the reserve should be released properly
1129          * (usually in ->dt_trans_stop()).
1130          *
1131          * \param[in] env       execution environment for this thread
1132          * \param[in] dt        object
1133          * \param[in] buf       buffer (including size) to copy data from
1134          * \param[in] pos       position in the object to start
1135          * \param[in] th        transaction handle
1136          *
1137          * \retval 0            on success
1138          * \retval negative     negated errno on error
1139          */
1140         ssize_t (*dbo_declare_write)(const struct lu_env *env,
1141                                      struct dt_object *dt,
1142                                      const struct lu_buf *buf,
1143                                      loff_t pos,
1144                                      struct thandle *th);
1145
1146         /**
1147          * Write unstructured data to regular existing object.
1148          *
1149          * The method allocates space and puts data in. Also, the method should
1150          * maintain attr.la_size properly. Partial writes are possible.
1151          *
1152          * If the layer implementing this method is responsible for quota,
1153          * then the method should maintain space accounting for the given
1154          * credentials.
1155          *
1156          * \param[in] env       execution environment for this thread
1157          * \param[in] dt        object
1158          * \param[in] buf       buffer (including size) to copy data from
1159          * \param[in] pos       position in the object to start
1160          * \param[out] pos      \a pos + bytes written
1161          * \param[in] th        transaction handle
1162          *
1163          * \retval positive     bytes written on success
1164          * \retval negative     negated errno on error
1165          */
1166         ssize_t (*dbo_write)(const struct lu_env *env,
1167                              struct dt_object *dt,
1168                              const struct lu_buf *buf,
1169                              loff_t *pos,
1170                              struct thandle *th);
1171
1172         /**
1173          * Return buffers for data.
1174          *
1175          * This method is used to access data with no copying. It's so-called
1176          * zero-copy I/O. The method returns the descriptors for the internal
1177          * buffers where data are managed by the disk filesystem. For example,
1178          * pagecache in case of ext4 or ARC with ZFS. Then other components
1179          * (e.g. networking) can transfer data from or to the buffers with no
1180          * additional copying.
1181          *
1182          * The method should fill an array of struct niobuf_local, where
1183          * each element describes a full or partial page for data at specific
1184          * offset. The caller should use page/lnb_page_offset/len to find data
1185          * at object's offset lnb_file_offset.
1186          *
1187          * The memory referenced by the descriptors can't change its purpose
1188          * until the complementary ->dbo_bufs_put() is called. The caller should
1189          * specify if the buffers are used to read or modify data so that OSD
1190          * can decide how to initialize the buffers: bring all the data for
1191          * reads or just bring partial buffers for write. Note: the method does
1192          * not check whether output array is large enough.
1193          *
1194          * \param[in] env       execution environment for this thread
1195          * \param[in] dt        object
1196          * \param[in] pos       position in the object to start
1197          * \param[in] len       size of region in bytes
1198          * \param[out] lb       array of descriptors to fill
1199          * \param[in] maxlnb    max slots in @lnb array
1200          * \param[in] rw        0 if used to read, 1 if used for write
1201          *
1202          * \retval positive     number of descriptors on success
1203          * \retval negative     negated errno on error
1204          */
1205         int (*dbo_bufs_get)(const struct lu_env *env,
1206                             struct dt_object *dt,
1207                             loff_t pos,
1208                             ssize_t len,
1209                             struct niobuf_local *lb,
1210                             int maxlnb,
1211                             enum dt_bufs_type rw);
1212
1213         /**
1214          * Release reference granted by ->dbo_bufs_get().
1215          *
1216          * Release the reference granted by the previous ->dbo_bufs_get().
1217          * Note the references are counted.
1218          *
1219          * \param[in] env       execution environment for this thread
1220          * \param[in] dt        object
1221          * \param[out] lb       array of descriptors to fill
1222          * \param[in] nr        size of the array
1223          *
1224          * \retval 0            on success
1225          * \retval negative     negated errno on error
1226          */
1227         int (*dbo_bufs_put)(const struct lu_env *env,
1228                             struct dt_object *dt,
1229                             struct niobuf_local *lb,
1230                             int nr);
1231
1232         /**
1233          * Prepare buffers for reading.
1234          *
1235          * The method is called on the given buffers to fill them with data
1236          * if that wasn't done in ->dbo_bufs_get(). The idea is that the
1237          * caller should be able to get few buffers for discontiguous regions
1238          * using few calls to ->dbo_bufs_get() and then request them all for
1239          * the preparation with a single call, so that OSD can fire many I/Os
1240          * to run concurrently. It's up to the specific OSD whether to implement
1241          * this logic in ->dbo_read_prep() or just use ->dbo_bufs_get() to
1242          * prepare data for every requested region individually.
1243          *
1244          * \param[in] env       execution environment for this thread
1245          * \param[in] dt        object
1246          * \param[in] lnb       array of buffer descriptors
1247          * \param[in] nr        size of the array
1248          *
1249          * \retval 0            on success
1250          * \retval negative     negated errno on error
1251          */
1252         int (*dbo_read_prep)(const struct lu_env *env,
1253                              struct dt_object *dt,
1254                              struct niobuf_local *lnb,
1255                              int nr);
1256
1257         /**
1258          * Prepare buffers for write.
1259          *
1260          * This method is called on the given buffers to ensure the partial
1261          * buffers contain correct data. The underlying idea is the same as
1262          * in ->db_read_prep().
1263          *
1264          * \param[in] env       execution environment for this thread
1265          * \param[in] dt        object
1266          * \param[in] lb        array of buffer descriptors
1267          * \param[in] nr        size of the array
1268          *
1269          * \retval 0            on success
1270          * \retval negative     negated errno on error
1271          */
1272         int (*dbo_write_prep)(const struct lu_env *env,
1273                               struct dt_object *dt,
1274                               struct niobuf_local *lb,
1275                               int nr);
1276
1277         /**
1278          * Declare intention to write data stored in the buffers.
1279          *
1280          * Notify the underlying filesystem that data may be written in
1281          * this transaction. This enables the layer below to prepare resources
1282          * (e.g. journal credits in ext4).  This method should be called
1283          * between creating the transaction and starting it.
1284          *
1285          * If the layer implementing this method is responsible for quota,
1286          * then the method should be reserving a space for the given
1287          * credentials and return an error if quota is exceeded. If the write
1288          * later fails for some reason, then the reserve should be released
1289          * properly (usually in ->dt_trans_stop()).
1290          *
1291          * \param[in] env       execution environment for this thread
1292          * \param[in] dt        object
1293          * \param[in] lb        array of descriptors
1294          * \param[in] nr        size of the array
1295          * \param[in] th        transaction handle
1296          *
1297          * \retval 0            on success
1298          * \retval negative     negated errno on error
1299          */
1300         int (*dbo_declare_write_commit)(const struct lu_env *env,
1301                                         struct dt_object *dt,
1302                                         struct niobuf_local *lb,
1303                                         int nr,
1304                                         struct thandle *th);
1305
1306         /**
1307          * Write to existing object.
1308          *
1309          * This method is used to write data to a persistent storage using
1310          * the buffers returned by ->dbo_bufs_get(). The caller puts new
1311          * data into the buffers using own mechanisms (e.g. direct transfer
1312          * from a NIC). The method should maintain attr.la_size. Also,
1313          * attr.la_blocks should be maintained but this can be done in lazy
1314          * manner, when actual allocation happens.
1315          *
1316          * If the layer implementing this method is responsible for quota,
1317          * then the method should maintain space accounting for the given
1318          * credentials.
1319          *
1320          * user_size parameter is the apparent size of the file, ie the size
1321          * of the clear text version of the file. It can differ from the actual
1322          * amount of valuable data received when a file is encrypted,
1323          * because encrypted pages always contain PAGE_SIZE bytes of data,
1324          * even if clear text data is only a few bytes.
1325          * In case of encrypted file, apparent size will be stored as the inode
1326          * size, so that servers return to clients an object size they can use
1327          * to determine clear text size.
1328          *
1329          * \param[in] env       execution environment for this thread
1330          * \param[in] dt        object
1331          * \param[in] lb        array of descriptors for the buffers
1332          * \param[in] nr        size of the array
1333          * \param[in] th        transaction handle
1334          * \param[in] user_size apparent size
1335          *
1336          * \retval 0            on success
1337          * \retval negative     negated errno on error
1338          */
1339         int (*dbo_write_commit)(const struct lu_env *env,
1340                                 struct dt_object *dt,
1341                                 struct niobuf_local *lb,
1342                                 int nr,
1343                                 struct thandle *th,
1344                                 __u64 user_size);
1345
1346         /**
1347          * Return logical to physical block mapping for a given extent
1348          *
1349          * \param[in] env       execution environment for this thread
1350          * \param[in] dt        object
1351          * \param[in] fm        describe the region to map and the output buffer
1352          *                      see the details in include/linux/fiemap.h
1353          *
1354          * \retval 0            on success
1355          * \retval negative     negated errno on error
1356          */
1357         int (*dbo_fiemap_get)(const struct lu_env *env,
1358                               struct dt_object *dt,
1359                               struct fiemap *fm);
1360
1361         /**
1362          * Declare intention to deallocate space from an object.
1363          *
1364          * Notify the underlying filesystem that space may be deallocated in
1365          * this transactions. This enables the layer below to prepare resources
1366          * (e.g. journal credits in ext4).  This method should be called between
1367          * creating the transaction and starting it. The object need not exist.
1368          *
1369          * \param[in] env       execution environment for this thread
1370          * \param[in] dt        object
1371          * \param[in] start     the start of the region to deallocate
1372          * \param[in] end       the end of the region to deallocate
1373          * \param[in] th        transaction handle
1374          *
1375          * \retval 0            on success
1376          * \retval negative     negated errno on error
1377          */
1378         int   (*dbo_declare_punch)(const struct lu_env *env,
1379                                    struct dt_object *dt,
1380                                    __u64 start,
1381                                    __u64 end,
1382                                    struct thandle *th);
1383
1384         /**
1385          * Deallocate specified region in an object.
1386          *
1387          * This method is used to deallocate (release) space possibly consumed
1388          * by the given region of the object. If the layer implementing this
1389          * method is responsible for quota, then the method should maintain
1390          * space accounting for the given credentials.
1391          *
1392          * \param[in] env       execution environment for this thread
1393          * \param[in] dt        object
1394          * \param[in] start     the start of the region to deallocate
1395          * \param[in] end       the end of the region to deallocate
1396          * \param[in] th        transaction handle
1397          *
1398          * \retval 0            on success
1399          * \retval negative     negated errno on error
1400          */
1401         int   (*dbo_punch)(const struct lu_env *env,
1402                            struct dt_object *dt,
1403                            __u64 start,
1404                            __u64 end,
1405                            struct thandle *th);
1406         /**
1407          * Give advices on specified region in an object.
1408          *
1409          * This method is used to give advices about access pattern on an
1410          * given region of the object. The disk filesystem understands
1411          * the advices and tunes cache/read-ahead policies.
1412          *
1413          * \param[in] env       execution environment for this thread
1414          * \param[in] dt        object
1415          * \param[in] start     the start of the region affected
1416          * \param[in] end       the end of the region affected
1417          * \param[in] advice    advice type
1418          *
1419          * \retval 0            on success
1420          * \retval negative     negated errno on error
1421          */
1422         int   (*dbo_ladvise)(const struct lu_env *env,
1423                              struct dt_object *dt,
1424                              __u64 start,
1425                              __u64 end,
1426                              enum lu_ladvise_type advice);
1427
1428         /**
1429          * Declare intention to preallocate space for an object
1430          *
1431          * \param[in] env       execution environment for this thread
1432          * \param[in] dt        object
1433          * \param[in] th        transaction handle
1434          *
1435          * \retval 0            on success
1436          * \retval negative     negated errno on error
1437          */
1438         int (*dbo_declare_fallocate)(const struct lu_env *env,
1439                                     struct dt_object *dt,
1440                                     struct thandle *th);
1441         /**
1442          * Allocate specified region for an object
1443          *
1444          * \param[in] env       execution environment for this thread
1445          * \param[in] dt        object
1446          * \param[in] start     the start of the region to allocate
1447          * \param[in] end       the end of the region to allocate
1448          * \param[in] mode      fallocate mode
1449          * \param[in] th        transaction handle
1450          *
1451          * \retval 0            on success
1452          * \retval negative     negated errno on error
1453          */
1454         int (*dbo_fallocate)(const struct lu_env *env,
1455                             struct dt_object *dt,
1456                             __u64 start,
1457                             __u64 end,
1458                             int mode,
1459                             struct thandle *th);
1460 };
1461
1462 /**
1463  * Incomplete type of index record.
1464  */
1465 struct dt_rec;
1466
1467 /**
1468  * Incomplete type of index key.
1469  */
1470 struct dt_key;
1471
1472 /**
1473  * Incomplete type of dt iterator.
1474  */
1475 struct dt_it;
1476
1477 /**
1478  * Per-dt-object operations on object as index. Index is a set of key/value
1479  * pairs abstracted from an on-disk representation. An index supports the
1480  * number of operations including lookup by key, insert and delete. Also,
1481  * an index can be iterated to find the pairs one by one, from a beginning
1482  * or specified point.
1483  */
1484 struct dt_index_operations {
1485         /**
1486          * Lookup in an index by key.
1487          *
1488          * The method returns a value for the given key. Key/value format
1489          * and size should have been negotiated with ->do_index_try() before.
1490          * Thus it's the caller's responsibility to provide the method with
1491          * proper key and big enough buffer. No external locking is required,
1492          * all the internal consistency should be implemented by the method
1493          * or lower layers. The object should should have been created with
1494          * type DFT_INDEX or DFT_DIR.
1495          *
1496          * \param[in] env       execution environment for this thread
1497          * \param[in] dt        object
1498          * \param[out] rec      buffer where value will be stored
1499          * \param[in] key       key
1500          *
1501          * \retval 0            on success
1502          * \retval -ENOENT      if key isn't found
1503          * \retval negative     negated errno on error
1504          */
1505         int (*dio_lookup)(const struct lu_env *env,
1506                           struct dt_object *dt,
1507                           struct dt_rec *rec,
1508                           const struct dt_key *key);
1509
1510         /**
1511          * Declare intention to insert a key/value into an index.
1512          *
1513          * Notify the underlying filesystem that new key/value may be inserted
1514          * in this transaction. This enables the layer below to prepare
1515          * resources (e.g. journal credits in ext4). This method should be
1516          * called between creating the transaction and starting it. key/value
1517          * format and size is subject to ->do_index_try().
1518          *
1519          * \param[in] env       execution environment for this thread
1520          * \param[in] dt        object
1521          * \param[in] rec       buffer storing value
1522          * \param[in] key       key
1523          * \param[in] th        transaction handle
1524          *
1525          * \retval 0            on success
1526          * \retval negative     negated errno on error
1527          */
1528         int (*dio_declare_insert)(const struct lu_env *env,
1529                                   struct dt_object *dt,
1530                                   const struct dt_rec *rec,
1531                                   const struct dt_key *key,
1532                                   struct thandle *th);
1533
1534         /**
1535          * Insert a new key/value pair into an index.
1536          *
1537          * The method inserts specified key/value pair into the given index
1538          * object. The internal consistency is maintained by the method or
1539          * the functionality below. The format and size of key/value should
1540          * have been negotiated before using ->do_index_try(), no additional
1541          * information can be specified to the method. The keys are unique
1542          * in a given index.
1543          *
1544          * \param[in] env       execution environment for this thread
1545          * \param[in] dt        object
1546          * \param[in] rec       buffer storing value
1547          * \param[in] key       key
1548          * \param[in] th        transaction handle
1549          *
1550          * \retval 0            on success
1551          * \retval negative     negated errno on error
1552          */
1553         int (*dio_insert)(const struct lu_env *env,
1554                           struct dt_object *dt,
1555                           const struct dt_rec *rec,
1556                           const struct dt_key *key,
1557                           struct thandle *th);
1558
1559         /**
1560          * Declare intention to delete a key/value from an index.
1561          *
1562          * Notify the underlying filesystem that key/value may be deleted in
1563          * this transaction. This enables the layer below to prepare resources
1564          * (e.g. journal credits in ext4).  This method should be called
1565          * between creating the transaction and starting it. Key/value format
1566          * and size is subject to ->do_index_try(). The object need not exist.
1567          *
1568          * \param[in] env       execution environment for this thread
1569          * \param[in] dt        object
1570          * \param[in] key       key
1571          * \param[in] th        transaction handle
1572          *
1573          * \retval 0            on success
1574          * \retval negative     negated errno on error
1575          */
1576         int (*dio_declare_delete)(const struct lu_env *env,
1577                                   struct dt_object *dt,
1578                                   const struct dt_key *key,
1579                                   struct thandle *th);
1580
1581         /**
1582          * Delete key/value pair from an index.
1583          *
1584          * The method deletes specified key and corresponding value from the
1585          * given index object. The internal consistency is maintained by the
1586          * method or the functionality below. The format and size of the key
1587          * should have been negotiated before using ->do_index_try(), no
1588          * additional information can be specified to the method.
1589          *
1590          * \param[in] env       execution environment for this thread
1591          * \param[in] dt        object
1592          * \param[in] key       key
1593          * \param[in] th        transaction handle
1594          *
1595          * \retval 0            on success
1596          * \retval negative     negated errno on error
1597          */
1598         int (*dio_delete)(const struct lu_env *env,
1599                           struct dt_object *dt,
1600                           const struct dt_key *key,
1601                           struct thandle *th);
1602
1603         /**
1604          * Iterator interface.
1605          *
1606          * Methods to iterate over an existing index, list the keys stored and
1607          * associated values, get key/value size, etc.
1608          */
1609         struct dt_it_ops {
1610                 /**
1611                  * Allocate and initialize new iterator.
1612                  *
1613                  * The iterator is a handler to be used in the subsequent
1614                  * methods to access index's content. Note the position is
1615                  * not defined at this point and should be initialized with
1616                  * ->get() or ->load() method.
1617                  *
1618                  * \param[in] env       execution environment for this thread
1619                  * \param[in] dt        object
1620                  * \param[in] attr      ask the iterator to return part of
1621                                         the records, see LUDA_* for details
1622                  *
1623                  * \retval pointer      iterator pointer on success
1624                  * \retval ERR_PTR(errno)       on error
1625                  */
1626                 struct dt_it *(*init)(const struct lu_env *env,
1627                                       struct dt_object *dt,
1628                                       __u32 attr);
1629
1630                 /**
1631                  * Release iterator.
1632                  *
1633                  * Release the specified iterator and all the resources
1634                  * associated (e.g. the object, index cache, etc).
1635                  *
1636                  * \param[in] env       execution environment for this thread
1637                  * \param[in] di        iterator to release
1638                  */
1639                 void          (*fini)(const struct lu_env *env,
1640                                       struct dt_it *di);
1641
1642                 /**
1643                  * Move position of iterator.
1644                  *
1645                  * Move the position of the specified iterator to the specified
1646                  * key.
1647                  *
1648                  * \param[in] env       execution environment for this thread
1649                  * \param[in] di        iterator
1650                  * \param[in] key       key to position to
1651                  *
1652                  * \retval 0            if exact key is found
1653                  * \retval 1            if at the record with least key
1654                  *                      not larger than the key
1655                  * \retval negative     negated errno on error
1656                  */
1657                 int            (*get)(const struct lu_env *env,
1658                                       struct dt_it *di,
1659                                       const struct dt_key *key);
1660
1661                 /**
1662                  * Release position
1663                  *
1664                  * Complimentary method for dt_it_ops::get() above. Some
1665                  * implementation can increase a reference on the iterator in
1666                  * dt_it_ops::get(). So the caller should be able to release
1667                  * with dt_it_ops::put().
1668                  *
1669                  * \param[in] env       execution environment for this thread
1670                  * \param[in] di        iterator
1671                  */
1672                 void           (*put)(const struct lu_env *env,
1673                                       struct dt_it *di);
1674
1675                 /**
1676                  * Move to next record.
1677                  *
1678                  * Moves the position of the iterator to a next record
1679                  *
1680                  * \param[in] env       execution environment for this thread
1681                  * \param[in] di        iterator
1682                  *
1683                  * \retval 1            if no more records
1684                  * \retval 0            on success, the next record is found
1685                  * \retval negative     negated errno on error
1686                  */
1687                 int           (*next)(const struct lu_env *env,
1688                                       struct dt_it *di);
1689
1690                 /**
1691                  * Return key.
1692                  *
1693                  * Returns a pointer to a buffer containing the key of the
1694                  * record at the current position. The pointer is valid and
1695                  * retains data until ->get(), ->load() and ->fini() methods
1696                  * are called.
1697                  *
1698                  * \param[in] env       execution environment for this thread
1699                  * \param[in] di        iterator
1700                  *
1701                  * \retval pointer to key       on success
1702                  * \retval ERR_PTR(errno)       on error
1703                  */
1704                 struct dt_key *(*key)(const struct lu_env *env,
1705                                       const struct dt_it *di);
1706
1707                 /**
1708                  * Return key size.
1709                  *
1710                  * Returns size of the key at the current position.
1711                  *
1712                  * \param[in] env       execution environment for this thread
1713                  * \param[in] di        iterator
1714                  *
1715                  * \retval key's size   on success
1716                  * \retval negative     negated errno on error
1717                  */
1718                 int       (*key_size)(const struct lu_env *env,
1719                                       const struct dt_it *di);
1720
1721                 /**
1722                  * Return record.
1723                  *
1724                  * Stores the value of the record at the current position. The
1725                  * buffer must be big enough (as negotiated with
1726                  * ->do_index_try() or ->rec_size()). The caller can specify
1727                  * she is interested only in part of the record, using attr
1728                  * argument (see LUDA_* definitions for the details).
1729                  *
1730                  * \param[in] env       execution environment for this thread
1731                  * \param[in] di        iterator
1732                  * \param[out] rec      buffer to store value in
1733                  * \param[in] attr      specify part of the value to copy
1734                  *
1735                  * \retval 0            on success
1736                  * \retval negative     negated errno on error
1737                  */
1738                 int            (*rec)(const struct lu_env *env,
1739                                       const struct dt_it *di,
1740                                       struct dt_rec *rec,
1741                                       __u32 attr);
1742
1743                 /**
1744                  * Return record size.
1745                  *
1746                  * Returns size of the record at the current position. The
1747                  * \a attr can be used to specify only the parts of the record
1748                  * needed to be returned. (see LUDA_* definitions for the
1749                  * details).
1750                  *
1751                  * \param[in] env       execution environment for this thread
1752                  * \param[in] di        iterator
1753                  * \param[in] attr      part of the record to return
1754                  *
1755                  * \retval record's size        on success
1756                  * \retval negative             negated errno on error
1757                  */
1758                 int        (*rec_size)(const struct lu_env *env,
1759                                        const struct dt_it *di,
1760                                       __u32 attr);
1761
1762                 /**
1763                  * Return a cookie (hash).
1764                  *
1765                  * Returns the cookie (usually hash) of the key at the current
1766                  * position. This allows the caller to resume iteration at this
1767                  * position later. The exact value is specific to implementation
1768                  * and should not be interpreted by the caller.
1769                  *
1770                  * \param[in] env       execution environment for this thread
1771                  * \param[in] di        iterator
1772                  *
1773                  * \retval cookie/hash of the key
1774                  */
1775                 __u64        (*store)(const struct lu_env *env,
1776                                       const struct dt_it *di);
1777
1778                 /**
1779                  * Initialize position using cookie/hash.
1780                  *
1781                  * Initializes the current position of the iterator to one
1782                  * described by the cookie/hash as returned by ->store()
1783                  * previously.
1784                  *
1785                  * \param[in] env       execution environment for this thread
1786                  * \param[in] di        iterator
1787                  * \param[in] hash      cookie/hash value
1788                  *
1789                  * \retval positive     if current position points to
1790                  *                      record with least cookie not larger
1791                  *                      than cookie
1792                  * \retval 0            if current position matches cookie
1793                  * \retval negative     negated errno on error
1794                  */
1795                 int           (*load)(const struct lu_env *env,
1796                                       const struct dt_it *di,
1797                                       __u64 hash);
1798
1799                 /**
1800                  * Not used
1801                  */
1802                 int        (*key_rec)(const struct lu_env *env,
1803                                       const struct dt_it *di,
1804                                       void *key_rec);
1805         } dio_it;
1806 };
1807
1808 enum dt_otable_it_valid {
1809         DOIV_ERROR_HANDLE       = 0x0001,
1810         DOIV_DRYRUN             = 0x0002,
1811 };
1812
1813 enum dt_otable_it_flags {
1814         /* Exit when fail. */
1815         DOIF_FAILOUT    = 0x0001,
1816
1817         /* Reset iteration position to the device beginning. */
1818         DOIF_RESET      = 0x0002,
1819
1820         /* There is up layer component uses the iteration. */
1821         DOIF_OUTUSED    = 0x0004,
1822
1823         /* Check only without repairing. */
1824         DOIF_DRYRUN     = 0x0008,
1825 };
1826
1827 /* otable based iteration needs to use the common DT iteration APIs.
1828  * To initialize the iteration, it needs call dio_it::init() firstly.
1829  * Here is how the otable based iteration should prepare arguments to
1830  * call dt_it_ops::init().
1831  *
1832  * For otable based iteration, the 32-bits 'attr' for dt_it_ops::init()
1833  * is composed of two parts:
1834  * low 16-bits is for valid bits, high 16-bits is for flags bits. */
1835 #define DT_OTABLE_IT_FLAGS_SHIFT        16
1836 #define DT_OTABLE_IT_FLAGS_MASK         0xffff0000
1837
1838 struct dt_device {
1839         struct lu_device                   dd_lu_dev;
1840         const struct dt_device_operations *dd_ops;
1841
1842         /**
1843          * List of dt_txn_callback (see below). This is not protected in any
1844          * way, because callbacks are supposed to be added/deleted only during
1845          * single-threaded start-up shut-down procedures.
1846          */
1847         struct list_head                   dd_txn_callbacks;
1848         unsigned int                       dd_record_fid_accessed:1,
1849                                            dd_rdonly:1;
1850
1851         /* sysfs and debugfs handling */
1852         struct dentry                     *dd_debugfs_entry;
1853
1854         const struct attribute           **dd_def_attrs;
1855         struct kobject                     dd_kobj;
1856         struct kobj_type                   dd_ktype;
1857         struct completion                  dd_kobj_unregister;
1858 };
1859
1860 int  dt_device_init(struct dt_device *dev, struct lu_device_type *t);
1861 void dt_device_fini(struct dt_device *dev);
1862
1863 static inline int lu_device_is_dt(const struct lu_device *d)
1864 {
1865         return ergo(d != NULL, d->ld_type->ldt_tags & LU_DEVICE_DT);
1866 }
1867
1868 static inline struct dt_device * lu2dt_dev(struct lu_device *l)
1869 {
1870         LASSERT(lu_device_is_dt(l));
1871         return container_of0(l, struct dt_device, dd_lu_dev);
1872 }
1873
1874 struct dt_object {
1875         struct lu_object                   do_lu;
1876         const struct dt_object_operations *do_ops;
1877         const struct dt_body_operations   *do_body_ops;
1878         const struct dt_index_operations  *do_index_ops;
1879 };
1880
1881 /*
1882  * In-core representation of per-device local object OID storage
1883  */
1884 struct local_oid_storage {
1885         /* all initialized llog systems on this node linked by this */
1886         struct list_head  los_list;
1887
1888         /* how many handle's reference this los has */
1889         atomic_t          los_refcount;
1890         struct dt_device *los_dev;
1891         struct dt_object *los_obj;
1892
1893         /* data used to generate new fids */
1894         struct mutex      los_id_lock;
1895         __u64             los_seq;
1896         __u32             los_last_oid;
1897 };
1898
1899 static inline struct lu_device *dt2lu_dev(struct dt_device *d)
1900 {
1901         return &d->dd_lu_dev;
1902 }
1903
1904 static inline struct dt_object *lu2dt(struct lu_object *l)
1905 {
1906         LASSERT(l == NULL || IS_ERR(l) || lu_device_is_dt(l->lo_dev));
1907         return container_of0(l, struct dt_object, do_lu);
1908 }
1909
1910 int  dt_object_init(struct dt_object *obj,
1911                     struct lu_object_header *h, struct lu_device *d);
1912
1913 void dt_object_fini(struct dt_object *obj);
1914
1915 static inline int dt_object_exists(const struct dt_object *dt)
1916 {
1917         return lu_object_exists(&dt->do_lu);
1918 }
1919
1920 static inline int dt_object_remote(const struct dt_object *dt)
1921 {
1922         return lu_object_remote(&dt->do_lu);
1923 }
1924
1925 static inline struct dt_object *lu2dt_obj(struct lu_object *o)
1926 {
1927         LASSERT(ergo(o != NULL, lu_device_is_dt(o->lo_dev)));
1928         return container_of0(o, struct dt_object, do_lu);
1929 }
1930
1931 static inline struct dt_object *dt_object_child(struct dt_object *o)
1932 {
1933         return container_of0(lu_object_next(&(o)->do_lu),
1934                              struct dt_object, do_lu);
1935 }
1936
1937 /**
1938  * This is the general purpose transaction handle.
1939  * 1. Transaction Life Cycle
1940  *      This transaction handle is allocated upon starting a new transaction,
1941  *      and deallocated after this transaction is committed.
1942  * 2. Transaction Nesting
1943  *      We do _NOT_ support nested transaction. So, every thread should only
1944  *      have one active transaction, and a transaction only belongs to one
1945  *      thread. Due to this, transaction handle need no reference count.
1946  * 3. Transaction & dt_object locking
1947  *      dt_object locks should be taken inside transaction.
1948  * 4. Transaction & RPC
1949  *      No RPC request should be issued inside transaction.
1950  */
1951 struct thandle {
1952         /** the dt device on which the transactions are executed */
1953         struct dt_device *th_dev;
1954
1955         /* point to the top thandle, XXX this is a bit hacky right now,
1956          * but normal device trans callback triggered by the bottom
1957          * device (OSP/OSD == sub thandle layer) needs to get the
1958          * top_thandle (see dt_txn_hook_start/stop()), so we put the
1959          * top thandle here for now, will fix it when we have better
1960          * callback mechanism */
1961         struct thandle  *th_top;
1962
1963         /** the last operation result in this transaction.
1964          * this value is used in recovery */
1965         __s32             th_result;
1966
1967         /** whether we need sync commit */
1968         unsigned int            th_sync:1,
1969         /* local transation, no need to inform other layers */
1970                                 th_local:1,
1971         /* Whether we need wait the transaction to be submitted
1972          * (send to remote target) */
1973                                 th_wait_submit:1,
1974         /* complex transaction which will track updates on all targets,
1975          * including OSTs */
1976                                 th_complex:1,
1977         /* whether ignore quota */
1978                                 th_ignore_quota:1;
1979 };
1980
1981 /**
1982  * Transaction call-backs.
1983  *
1984  * These are invoked by osd (or underlying transaction engine) when
1985  * transaction changes state.
1986  *
1987  * Call-backs are used by upper layers to modify transaction parameters and to
1988  * perform some actions on for each transaction state transition. Typical
1989  * example is mdt registering call-back to write into last-received file
1990  * before each transaction commit.
1991  */
1992 struct dt_txn_callback {
1993         int (*dtc_txn_start)(const struct lu_env *env,
1994                              struct thandle *txn, void *cookie);
1995         int (*dtc_txn_stop)(const struct lu_env *env,
1996                             struct thandle *txn, void *cookie);
1997         void                    *dtc_cookie;
1998         __u32                   dtc_tag;
1999         struct list_head        dtc_linkage;
2000 };
2001
2002 void dt_txn_callback_add(struct dt_device *dev, struct dt_txn_callback *cb);
2003 void dt_txn_callback_del(struct dt_device *dev, struct dt_txn_callback *cb);
2004
2005 int dt_txn_hook_start(const struct lu_env *env,
2006                       struct dt_device *dev, struct thandle *txn);
2007 int dt_txn_hook_stop(const struct lu_env *env, struct thandle *txn);
2008
2009 int dt_try_as_dir(const struct lu_env *env, struct dt_object *obj);
2010
2011 /**
2012  * Callback function used for parsing path.
2013  * \see llo_store_resolve
2014  */
2015 typedef int (*dt_entry_func_t)(const struct lu_env *env,
2016                             const char *name,
2017                             void *pvt);
2018
2019 #define DT_MAX_PATH 1024
2020
2021 int dt_path_parser(const struct lu_env *env,
2022                    char *local, dt_entry_func_t entry_func,
2023                    void *data);
2024
2025 struct dt_object *
2026 dt_store_resolve(const struct lu_env *env, struct dt_device *dt,
2027                  const char *path, struct lu_fid *fid);
2028
2029 struct dt_object *dt_store_open(const struct lu_env *env,
2030                                 struct dt_device *dt,
2031                                 const char *dirname,
2032                                 const char *filename,
2033                                 struct lu_fid *fid);
2034
2035 struct dt_object *dt_find_or_create(const struct lu_env *env,
2036                                     struct dt_device *dt,
2037                                     const struct lu_fid *fid,
2038                                     struct dt_object_format *dof,
2039                                     struct lu_attr *attr);
2040
2041 struct dt_object *dt_locate_at(const struct lu_env *env,
2042                                struct dt_device *dev,
2043                                const struct lu_fid *fid,
2044                                struct lu_device *top_dev,
2045                                const struct lu_object_conf *conf);
2046
2047 static inline struct dt_object *
2048 dt_locate(const struct lu_env *env, struct dt_device *dev,
2049           const struct lu_fid *fid)
2050 {
2051         return dt_locate_at(env, dev, fid,
2052                             dev->dd_lu_dev.ld_site->ls_top_dev, NULL);
2053 }
2054
2055 static inline struct dt_object *
2056 dt_object_locate(struct dt_object *dto, struct dt_device *dt_dev)
2057 {
2058         struct lu_object *lo;
2059
2060         list_for_each_entry(lo, &dto->do_lu.lo_header->loh_layers, lo_linkage) {
2061                 if (lo->lo_dev == &dt_dev->dd_lu_dev)
2062                         return container_of(lo, struct dt_object, do_lu);
2063         }
2064         return NULL;
2065 }
2066
2067 static inline void dt_object_put(const struct lu_env *env,
2068                                  struct dt_object *dto)
2069 {
2070         lu_object_put(env, &dto->do_lu);
2071 }
2072
2073 static inline void dt_object_put_nocache(const struct lu_env *env,
2074                                          struct dt_object *dto)
2075 {
2076         lu_object_put_nocache(env, &dto->do_lu);
2077 }
2078
2079 int local_oid_storage_init(const struct lu_env *env, struct dt_device *dev,
2080                            const struct lu_fid *first_fid,
2081                            struct local_oid_storage **los);
2082 void local_oid_storage_fini(const struct lu_env *env,
2083                             struct local_oid_storage *los);
2084 int local_object_fid_generate(const struct lu_env *env,
2085                               struct local_oid_storage *los,
2086                               struct lu_fid *fid);
2087 int local_object_declare_create(const struct lu_env *env,
2088                                 struct local_oid_storage *los,
2089                                 struct dt_object *o,
2090                                 struct lu_attr *attr,
2091                                 struct dt_object_format *dof,
2092                                 struct thandle *th);
2093 int local_object_create(const struct lu_env *env,
2094                         struct local_oid_storage *los,
2095                         struct dt_object *o,
2096                         struct lu_attr *attr, struct dt_object_format *dof,
2097                         struct thandle *th);
2098 struct dt_object *local_file_find(const struct lu_env *env,
2099                                   struct local_oid_storage *los,
2100                                   struct dt_object *parent,
2101                                   const char *name);
2102 struct dt_object *local_file_find_or_create(const struct lu_env *env,
2103                                             struct local_oid_storage *los,
2104                                             struct dt_object *parent,
2105                                             const char *name, __u32 mode);
2106 struct dt_object *local_file_find_or_create_with_fid(const struct lu_env *env,
2107                                                      struct dt_device *dt,
2108                                                      const struct lu_fid *fid,
2109                                                      struct dt_object *parent,
2110                                                      const char *name,
2111                                                      __u32 mode);
2112 struct dt_object *
2113 local_index_find_or_create(const struct lu_env *env,
2114                            struct local_oid_storage *los,
2115                            struct dt_object *parent,
2116                            const char *name, __u32 mode,
2117                            const struct dt_index_features *ft);
2118 struct dt_object *
2119 local_index_find_or_create_with_fid(const struct lu_env *env,
2120                                     struct dt_device *dt,
2121                                     const struct lu_fid *fid,
2122                                     struct dt_object *parent,
2123                                     const char *name, __u32 mode,
2124                                     const struct dt_index_features *ft);
2125 int local_object_unlink(const struct lu_env *env, struct dt_device *dt,
2126                         struct dt_object *parent, const char *name);
2127
2128 static inline int dt_object_lock(const struct lu_env *env,
2129                                  struct dt_object *o, struct lustre_handle *lh,
2130                                  struct ldlm_enqueue_info *einfo,
2131                                  union ldlm_policy_data *policy)
2132 {
2133         LASSERT(o != NULL);
2134         LASSERT(o->do_ops != NULL);
2135         LASSERT(o->do_ops->do_object_lock != NULL);
2136         return o->do_ops->do_object_lock(env, o, lh, einfo, policy);
2137 }
2138
2139 static inline int dt_object_unlock(const struct lu_env *env,
2140                                    struct dt_object *o,
2141                                    struct ldlm_enqueue_info *einfo,
2142                                    union ldlm_policy_data *policy)
2143 {
2144         LASSERT(o != NULL);
2145         LASSERT(o->do_ops != NULL);
2146         LASSERT(o->do_ops->do_object_unlock != NULL);
2147         return o->do_ops->do_object_unlock(env, o, einfo, policy);
2148 }
2149
2150 int dt_lookup_dir(const struct lu_env *env, struct dt_object *dir,
2151                   const char *name, struct lu_fid *fid);
2152
2153 static inline int dt_object_sync(const struct lu_env *env, struct dt_object *o,
2154                                  __u64 start, __u64 end)
2155 {
2156         LASSERT(o);
2157         LASSERT(o->do_ops);
2158         LASSERT(o->do_ops->do_object_sync);
2159         return o->do_ops->do_object_sync(env, o, start, end);
2160 }
2161
2162 static inline int dt_fid_alloc(const struct lu_env *env,
2163                                struct dt_device *d,
2164                                struct lu_fid *fid,
2165                                struct lu_object *parent,
2166                                const struct lu_name *name)
2167 {
2168         struct lu_device *l = dt2lu_dev(d);
2169
2170         return l->ld_ops->ldo_fid_alloc(env, l, fid, parent, name);
2171 }
2172
2173 int dt_declare_version_set(const struct lu_env *env, struct dt_object *o,
2174                            struct thandle *th);
2175 void dt_version_set(const struct lu_env *env, struct dt_object *o,
2176                     dt_obj_version_t version, struct thandle *th);
2177 dt_obj_version_t dt_version_get(const struct lu_env *env, struct dt_object *o);
2178
2179
2180 int dt_read(const struct lu_env *env, struct dt_object *dt,
2181             struct lu_buf *buf, loff_t *pos);
2182 int dt_record_read(const struct lu_env *env, struct dt_object *dt,
2183                    struct lu_buf *buf, loff_t *pos);
2184 int dt_record_write(const struct lu_env *env, struct dt_object *dt,
2185                     const struct lu_buf *buf, loff_t *pos, struct thandle *th);
2186 typedef int (*dt_index_page_build_t)(const struct lu_env *env,
2187                                      union lu_page *lp, size_t nob,
2188                                      const struct dt_it_ops *iops,
2189                                      struct dt_it *it, __u32 attr, void *arg);
2190 int dt_index_walk(const struct lu_env *env, struct dt_object *obj,
2191                   const struct lu_rdpg *rdpg, dt_index_page_build_t filler,
2192                   void *arg);
2193 int dt_index_read(const struct lu_env *env, struct dt_device *dev,
2194                   struct idx_info *ii, const struct lu_rdpg *rdpg);
2195
2196 static inline struct thandle *dt_trans_create(const struct lu_env *env,
2197                                               struct dt_device *d)
2198 {
2199         LASSERT(d->dd_ops->dt_trans_create);
2200         return d->dd_ops->dt_trans_create(env, d);
2201 }
2202
2203 static inline int dt_trans_start(const struct lu_env *env,
2204                                  struct dt_device *d, struct thandle *th)
2205 {
2206         LASSERT(d->dd_ops->dt_trans_start);
2207         return d->dd_ops->dt_trans_start(env, d, th);
2208 }
2209
2210 /* for this transaction hooks shouldn't be called */
2211 static inline int dt_trans_start_local(const struct lu_env *env,
2212                                        struct dt_device *d, struct thandle *th)
2213 {
2214         LASSERT(d->dd_ops->dt_trans_start);
2215         th->th_local = 1;
2216         return d->dd_ops->dt_trans_start(env, d, th);
2217 }
2218
2219 static inline int dt_trans_stop(const struct lu_env *env,
2220                                 struct dt_device *d, struct thandle *th)
2221 {
2222         LASSERT(d->dd_ops->dt_trans_stop);
2223         return d->dd_ops->dt_trans_stop(env, d, th);
2224 }
2225
2226 static inline int dt_trans_cb_add(struct thandle *th,
2227                                   struct dt_txn_commit_cb *dcb)
2228 {
2229         LASSERT(th->th_dev->dd_ops->dt_trans_cb_add);
2230         dcb->dcb_magic = TRANS_COMMIT_CB_MAGIC;
2231         return th->th_dev->dd_ops->dt_trans_cb_add(th, dcb);
2232 }
2233 /** @} dt */
2234
2235
2236 static inline int dt_declare_record_write(const struct lu_env *env,
2237                                           struct dt_object *dt,
2238                                           const struct lu_buf *buf,
2239                                           loff_t pos,
2240                                           struct thandle *th)
2241 {
2242         int rc;
2243
2244         LASSERTF(dt != NULL, "dt is NULL when we want to write record\n");
2245         LASSERT(th != NULL);
2246         LASSERT(dt->do_body_ops);
2247         LASSERT(dt->do_body_ops->dbo_declare_write);
2248         rc = dt->do_body_ops->dbo_declare_write(env, dt, buf, pos, th);
2249         return rc;
2250 }
2251
2252 static inline int dt_declare_create(const struct lu_env *env,
2253                                     struct dt_object *dt,
2254                                     struct lu_attr *attr,
2255                                     struct dt_allocation_hint *hint,
2256                                     struct dt_object_format *dof,
2257                                     struct thandle *th)
2258 {
2259         LASSERT(dt);
2260         LASSERT(dt->do_ops);
2261         LASSERT(dt->do_ops->do_declare_create);
2262
2263         if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_CREATE))
2264                 return cfs_fail_err;
2265
2266         return dt->do_ops->do_declare_create(env, dt, attr, hint, dof, th);
2267 }
2268
2269 static inline int dt_create(const struct lu_env *env,
2270                                     struct dt_object *dt,
2271                                     struct lu_attr *attr,
2272                                     struct dt_allocation_hint *hint,
2273                                     struct dt_object_format *dof,
2274                                     struct thandle *th)
2275 {
2276         LASSERT(dt);
2277         LASSERT(dt->do_ops);
2278         LASSERT(dt->do_ops->do_create);
2279
2280         if (CFS_FAULT_CHECK(OBD_FAIL_DT_CREATE))
2281                 return cfs_fail_err;
2282
2283         return dt->do_ops->do_create(env, dt, attr, hint, dof, th);
2284 }
2285
2286 static inline int dt_declare_destroy(const struct lu_env *env,
2287                                      struct dt_object *dt,
2288                                      struct thandle *th)
2289 {
2290         LASSERT(dt);
2291         LASSERT(dt->do_ops);
2292         LASSERT(dt->do_ops->do_declare_destroy);
2293
2294         if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_DESTROY))
2295                 return cfs_fail_err;
2296
2297         return dt->do_ops->do_declare_destroy(env, dt, th);
2298 }
2299
2300 static inline int dt_destroy(const struct lu_env *env,
2301                              struct dt_object *dt,
2302                              struct thandle *th)
2303 {
2304         LASSERT(dt);
2305         LASSERT(dt->do_ops);
2306         LASSERT(dt->do_ops->do_destroy);
2307
2308         if (CFS_FAULT_CHECK(OBD_FAIL_DT_DESTROY))
2309                 return cfs_fail_err;
2310
2311         return dt->do_ops->do_destroy(env, dt, th);
2312 }
2313
2314 static inline void dt_read_lock(const struct lu_env *env,
2315                                 struct dt_object *dt,
2316                                 unsigned role)
2317 {
2318         LASSERT(dt);
2319         LASSERT(dt->do_ops);
2320         LASSERT(dt->do_ops->do_read_lock);
2321         dt->do_ops->do_read_lock(env, dt, role);
2322 }
2323
2324 static inline void dt_write_lock(const struct lu_env *env,
2325                                 struct dt_object *dt,
2326                                 unsigned role)
2327 {
2328         LASSERT(dt);
2329         LASSERT(dt->do_ops);
2330         LASSERT(dt->do_ops->do_write_lock);
2331         dt->do_ops->do_write_lock(env, dt, role);
2332 }
2333
2334 static inline void dt_read_unlock(const struct lu_env *env,
2335                                 struct dt_object *dt)
2336 {
2337         LASSERT(dt);
2338         LASSERT(dt->do_ops);
2339         LASSERT(dt->do_ops->do_read_unlock);
2340         dt->do_ops->do_read_unlock(env, dt);
2341 }
2342
2343 static inline void dt_write_unlock(const struct lu_env *env,
2344                                 struct dt_object *dt)
2345 {
2346         LASSERT(dt);
2347         LASSERT(dt->do_ops);
2348         LASSERT(dt->do_ops->do_write_unlock);
2349         dt->do_ops->do_write_unlock(env, dt);
2350 }
2351
2352 static inline int dt_write_locked(const struct lu_env *env,
2353                                   struct dt_object *dt)
2354 {
2355         LASSERT(dt);
2356         LASSERT(dt->do_ops);
2357         LASSERT(dt->do_ops->do_write_locked);
2358         return dt->do_ops->do_write_locked(env, dt);
2359 }
2360
2361 static inline int dt_declare_attr_get(const struct lu_env *env,
2362                                       struct dt_object *dt)
2363 {
2364         LASSERT(dt);
2365         LASSERT(dt->do_ops);
2366         LASSERT(dt->do_ops->do_declare_attr_get);
2367
2368         if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_ATTR_GET))
2369                 return cfs_fail_err;
2370
2371         return dt->do_ops->do_declare_attr_get(env, dt);
2372 }
2373
2374 static inline int dt_attr_get(const struct lu_env *env, struct dt_object *dt,
2375                               struct lu_attr *la)
2376 {
2377         LASSERT(dt);
2378         LASSERT(dt->do_ops);
2379         LASSERT(dt->do_ops->do_attr_get);
2380
2381         if (CFS_FAULT_CHECK(OBD_FAIL_DT_ATTR_GET))
2382                 return cfs_fail_err;
2383
2384         return dt->do_ops->do_attr_get(env, dt, la);
2385 }
2386
2387 static inline int dt_declare_attr_set(const struct lu_env *env,
2388                                       struct dt_object *dt,
2389                                       const struct lu_attr *la,
2390                                       struct thandle *th)
2391 {
2392         LASSERT(dt);
2393         LASSERT(dt->do_ops);
2394         LASSERT(dt->do_ops->do_declare_attr_set);
2395
2396         if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_ATTR_SET))
2397                 return cfs_fail_err;
2398
2399         return dt->do_ops->do_declare_attr_set(env, dt, la, th);
2400 }
2401
2402 static inline int dt_attr_set(const struct lu_env *env, struct dt_object *dt,
2403                               const struct lu_attr *la, struct thandle *th)
2404 {
2405         LASSERT(dt);
2406         LASSERT(dt->do_ops);
2407         LASSERT(dt->do_ops->do_attr_set);
2408
2409         if (CFS_FAULT_CHECK(OBD_FAIL_DT_ATTR_SET))
2410                 return cfs_fail_err;
2411
2412         return dt->do_ops->do_attr_set(env, dt, la, th);
2413 }
2414
2415 static inline int dt_declare_ref_add(const struct lu_env *env,
2416                                      struct dt_object *dt, struct thandle *th)
2417 {
2418         LASSERT(dt);
2419         LASSERT(dt->do_ops);
2420         LASSERT(dt->do_ops->do_declare_ref_add);
2421
2422         if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_REF_ADD))
2423                 return cfs_fail_err;
2424
2425         return dt->do_ops->do_declare_ref_add(env, dt, th);
2426 }
2427
2428 static inline int dt_ref_add(const struct lu_env *env,
2429                              struct dt_object *dt, struct thandle *th)
2430 {
2431         LASSERT(dt);
2432         LASSERT(dt->do_ops);
2433         LASSERT(dt->do_ops->do_ref_add);
2434
2435         if (CFS_FAULT_CHECK(OBD_FAIL_DT_REF_ADD))
2436                 return cfs_fail_err;
2437
2438         return dt->do_ops->do_ref_add(env, dt, th);
2439 }
2440
2441 static inline int dt_declare_ref_del(const struct lu_env *env,
2442                                      struct dt_object *dt, struct thandle *th)
2443 {
2444         LASSERT(dt);
2445         LASSERT(dt->do_ops);
2446         LASSERT(dt->do_ops->do_declare_ref_del);
2447
2448         if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_REF_DEL))
2449                 return cfs_fail_err;
2450
2451         return dt->do_ops->do_declare_ref_del(env, dt, th);
2452 }
2453
2454 static inline int dt_ref_del(const struct lu_env *env,
2455                              struct dt_object *dt, struct thandle *th)
2456 {
2457         LASSERT(dt);
2458         LASSERT(dt->do_ops);
2459         LASSERT(dt->do_ops->do_ref_del);
2460
2461         if (CFS_FAULT_CHECK(OBD_FAIL_DT_REF_DEL))
2462                 return cfs_fail_err;
2463
2464         return dt->do_ops->do_ref_del(env, dt, th);
2465 }
2466
2467 static inline int dt_bufs_get(const struct lu_env *env, struct dt_object *d,
2468                               struct niobuf_remote *rnb,
2469                               struct niobuf_local *lnb, int maxlnb,
2470                               enum dt_bufs_type rw)
2471 {
2472         LASSERT(d);
2473         LASSERT(d->do_body_ops);
2474         LASSERT(d->do_body_ops->dbo_bufs_get);
2475         return d->do_body_ops->dbo_bufs_get(env, d, rnb->rnb_offset,
2476                                             rnb->rnb_len, lnb, maxlnb, rw);
2477 }
2478
2479 static inline int dt_bufs_put(const struct lu_env *env, struct dt_object *d,
2480                               struct niobuf_local *lnb, int n)
2481 {
2482         LASSERT(d);
2483         LASSERT(d->do_body_ops);
2484         LASSERT(d->do_body_ops->dbo_bufs_put);
2485         return d->do_body_ops->dbo_bufs_put(env, d, lnb, n);
2486 }
2487
2488 static inline int dt_write_prep(const struct lu_env *env, struct dt_object *d,
2489                                 struct niobuf_local *lnb, int n)
2490 {
2491         LASSERT(d);
2492         LASSERT(d->do_body_ops);
2493         LASSERT(d->do_body_ops->dbo_write_prep);
2494         return d->do_body_ops->dbo_write_prep(env, d, lnb, n);
2495 }
2496
2497 static inline int dt_declare_write_commit(const struct lu_env *env,
2498                                           struct dt_object *d,
2499                                           struct niobuf_local *lnb,
2500                                           int n, struct thandle *th)
2501 {
2502         LASSERTF(d != NULL, "dt is NULL when we want to declare write\n");
2503         LASSERT(th != NULL);
2504         return d->do_body_ops->dbo_declare_write_commit(env, d, lnb, n, th);
2505 }
2506
2507
2508 static inline int dt_write_commit(const struct lu_env *env,
2509                                   struct dt_object *d, struct niobuf_local *lnb,
2510                                   int n, struct thandle *th, __u64 size)
2511 {
2512         LASSERT(d);
2513         LASSERT(d->do_body_ops);
2514         LASSERT(d->do_body_ops->dbo_write_commit);
2515         return d->do_body_ops->dbo_write_commit(env, d, lnb, n, th, size);
2516 }
2517
2518 static inline int dt_read_prep(const struct lu_env *env, struct dt_object *d,
2519                                struct niobuf_local *lnb, int n)
2520 {
2521         LASSERT(d);
2522         LASSERT(d->do_body_ops);
2523         LASSERT(d->do_body_ops->dbo_read_prep);
2524         return d->do_body_ops->dbo_read_prep(env, d, lnb, n);
2525 }
2526
2527 static inline int dt_declare_write(const struct lu_env *env,
2528                                    struct dt_object *dt,
2529                                    const struct lu_buf *buf, loff_t pos,
2530                                    struct thandle *th)
2531 {
2532         LASSERT(dt);
2533         LASSERT(dt->do_body_ops);
2534         LASSERT(dt->do_body_ops->dbo_declare_write);
2535         return dt->do_body_ops->dbo_declare_write(env, dt, buf, pos, th);
2536 }
2537
2538 static inline ssize_t dt_write(const struct lu_env *env, struct dt_object *dt,
2539                                const struct lu_buf *buf, loff_t *pos,
2540                                struct thandle *th)
2541 {
2542         LASSERT(dt);
2543         LASSERT(dt->do_body_ops);
2544         LASSERT(dt->do_body_ops->dbo_write);
2545         return dt->do_body_ops->dbo_write(env, dt, buf, pos, th);
2546 }
2547
2548 static inline int dt_declare_punch(const struct lu_env *env,
2549                                    struct dt_object *dt, __u64 start,
2550                                    __u64 end, struct thandle *th)
2551 {
2552         LASSERT(dt);
2553         LASSERT(dt->do_body_ops);
2554         LASSERT(dt->do_body_ops->dbo_declare_punch);
2555         return dt->do_body_ops->dbo_declare_punch(env, dt, start, end, th);
2556 }
2557
2558 static inline int dt_punch(const struct lu_env *env, struct dt_object *dt,
2559                            __u64 start, __u64 end, struct thandle *th)
2560 {
2561         LASSERT(dt);
2562         LASSERT(dt->do_body_ops);
2563         LASSERT(dt->do_body_ops->dbo_punch);
2564         return dt->do_body_ops->dbo_punch(env, dt, start, end, th);
2565 }
2566
2567 static inline int dt_ladvise(const struct lu_env *env, struct dt_object *dt,
2568                              __u64 start, __u64 end, int advice)
2569 {
2570         LASSERT(dt);
2571         LASSERT(dt->do_body_ops);
2572         LASSERT(dt->do_body_ops->dbo_ladvise);
2573         return dt->do_body_ops->dbo_ladvise(env, dt, start, end, advice);
2574 }
2575
2576 static inline int dt_declare_falloc(const struct lu_env *env,
2577                                       struct dt_object *dt, struct thandle *th)
2578 {
2579         LASSERT(dt);
2580         if (!dt->do_body_ops)
2581                 return -EOPNOTSUPP;
2582         LASSERT(dt->do_body_ops);
2583         LASSERT(dt->do_body_ops->dbo_declare_fallocate);
2584         return dt->do_body_ops->dbo_declare_fallocate(env, dt, th);
2585 }
2586
2587 static inline int dt_falloc(const struct lu_env *env, struct dt_object *dt,
2588                               __u64 start, __u64 end, int mode,
2589                               struct thandle *th)
2590 {
2591         LASSERT(dt);
2592         if (!dt->do_body_ops)
2593                 return -EOPNOTSUPP;
2594         LASSERT(dt->do_body_ops);
2595         LASSERT(dt->do_body_ops->dbo_fallocate);
2596         return dt->do_body_ops->dbo_fallocate(env, dt, start, end, mode, th);
2597 }
2598
2599 static inline int dt_fiemap_get(const struct lu_env *env, struct dt_object *d,
2600                                 struct fiemap *fm)
2601 {
2602         LASSERT(d);
2603         if (d->do_body_ops == NULL)
2604                 return -EPROTO;
2605         if (d->do_body_ops->dbo_fiemap_get == NULL)
2606                 return -EOPNOTSUPP;
2607         return d->do_body_ops->dbo_fiemap_get(env, d, fm);
2608 }
2609
2610 static inline int dt_statfs_info(const struct lu_env *env,
2611                                  struct dt_device *dev,
2612                                 struct obd_statfs *osfs,
2613                                 struct obd_statfs_info *info)
2614 {
2615         LASSERT(dev);
2616         LASSERT(dev->dd_ops);
2617         LASSERT(dev->dd_ops->dt_statfs);
2618         return dev->dd_ops->dt_statfs(env, dev, osfs, info);
2619 }
2620
2621 static inline int dt_statfs(const struct lu_env *env, struct dt_device *dev,
2622                             struct obd_statfs *osfs)
2623 {
2624         return dt_statfs_info(env, dev, osfs, NULL);
2625 }
2626
2627 static inline int dt_root_get(const struct lu_env *env, struct dt_device *dev,
2628                               struct lu_fid *f)
2629 {
2630         LASSERT(dev);
2631         LASSERT(dev->dd_ops);
2632         LASSERT(dev->dd_ops->dt_root_get);
2633         return dev->dd_ops->dt_root_get(env, dev, f);
2634 }
2635
2636 static inline void dt_conf_get(const struct lu_env *env,
2637                                const struct dt_device *dev,
2638                                struct dt_device_param *param)
2639 {
2640         LASSERT(dev);
2641         LASSERT(dev->dd_ops);
2642         LASSERT(dev->dd_ops->dt_conf_get);
2643         return dev->dd_ops->dt_conf_get(env, dev, param);
2644 }
2645
2646 static inline struct super_block *dt_mnt_sb_get(const struct dt_device *dev)
2647 {
2648         LASSERT(dev);
2649         LASSERT(dev->dd_ops);
2650         if (dev->dd_ops->dt_mnt_sb_get)
2651                 return dev->dd_ops->dt_mnt_sb_get(dev);
2652
2653         return ERR_PTR(-EOPNOTSUPP);
2654 }
2655
2656 static inline int dt_sync(const struct lu_env *env, struct dt_device *dev)
2657 {
2658         LASSERT(dev);
2659         LASSERT(dev->dd_ops);
2660         LASSERT(dev->dd_ops->dt_sync);
2661         return dev->dd_ops->dt_sync(env, dev);
2662 }
2663
2664 static inline int dt_ro(const struct lu_env *env, struct dt_device *dev)
2665 {
2666         LASSERT(dev);
2667         LASSERT(dev->dd_ops);
2668         LASSERT(dev->dd_ops->dt_ro);
2669         return dev->dd_ops->dt_ro(env, dev);
2670 }
2671
2672 static inline int dt_declare_insert(const struct lu_env *env,
2673                                     struct dt_object *dt,
2674                                     const struct dt_rec *rec,
2675                                     const struct dt_key *key,
2676                                     struct thandle *th)
2677 {
2678         LASSERT(dt);
2679         LASSERT(dt->do_index_ops);
2680         LASSERT(dt->do_index_ops->dio_declare_insert);
2681
2682         if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_INSERT))
2683                 return cfs_fail_err;
2684
2685         return dt->do_index_ops->dio_declare_insert(env, dt, rec, key, th);
2686 }
2687
2688 static inline int dt_insert(const struct lu_env *env,
2689                             struct dt_object *dt,
2690                             const struct dt_rec *rec,
2691                             const struct dt_key *key,
2692                             struct thandle *th)
2693 {
2694         LASSERT(dt);
2695         LASSERT(dt->do_index_ops);
2696         LASSERT(dt->do_index_ops->dio_insert);
2697
2698         if (CFS_FAULT_CHECK(OBD_FAIL_DT_INSERT))
2699                 return cfs_fail_err;
2700
2701         return dt->do_index_ops->dio_insert(env, dt, rec, key, th);
2702 }
2703
2704 static inline int dt_declare_xattr_del(const struct lu_env *env,
2705                                        struct dt_object *dt,
2706                                        const char *name,
2707                                        struct thandle *th)
2708 {
2709         LASSERT(dt);
2710         LASSERT(dt->do_ops);
2711         LASSERT(dt->do_ops->do_declare_xattr_del);
2712
2713         if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_XATTR_DEL))
2714                 return cfs_fail_err;
2715
2716         return dt->do_ops->do_declare_xattr_del(env, dt, name, th);
2717 }
2718
2719 static inline int dt_xattr_del(const struct lu_env *env,
2720                                struct dt_object *dt, const char *name,
2721                                struct thandle *th)
2722 {
2723         LASSERT(dt);
2724         LASSERT(dt->do_ops);
2725         LASSERT(dt->do_ops->do_xattr_del);
2726
2727         if (CFS_FAULT_CHECK(OBD_FAIL_DT_XATTR_DEL))
2728                 return cfs_fail_err;
2729
2730         return dt->do_ops->do_xattr_del(env, dt, name, th);
2731 }
2732
2733 static inline int dt_declare_xattr_set(const struct lu_env *env,
2734                                       struct dt_object *dt,
2735                                       const struct lu_buf *buf,
2736                                       const char *name, int fl,
2737                                       struct thandle *th)
2738 {
2739         LASSERT(dt);
2740         LASSERT(dt->do_ops);
2741         LASSERT(dt->do_ops->do_declare_xattr_set);
2742
2743         if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_XATTR_SET))
2744                 return cfs_fail_err;
2745
2746         return dt->do_ops->do_declare_xattr_set(env, dt, buf, name, fl, th);
2747 }
2748
2749 static inline int dt_xattr_set(const struct lu_env *env,
2750                                struct dt_object *dt, const struct lu_buf *buf,
2751                                const char *name, int fl, struct thandle *th)
2752 {
2753         LASSERT(dt);
2754         LASSERT(dt->do_ops);
2755         LASSERT(dt->do_ops->do_xattr_set);
2756
2757         if (CFS_FAULT_CHECK(OBD_FAIL_DT_XATTR_SET))
2758                 return cfs_fail_err;
2759
2760         return dt->do_ops->do_xattr_set(env, dt, buf, name, fl, th);
2761 }
2762
2763 static inline int dt_declare_xattr_get(const struct lu_env *env,
2764                                        struct dt_object *dt,
2765                                        struct lu_buf *buf,
2766                                        const char *name)
2767 {
2768         LASSERT(dt);
2769         LASSERT(dt->do_ops);
2770         LASSERT(dt->do_ops->do_declare_xattr_get);
2771
2772         if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_XATTR_GET))
2773                 return cfs_fail_err;
2774
2775         return dt->do_ops->do_declare_xattr_get(env, dt, buf, name);
2776 }
2777
2778 static inline int dt_xattr_get(const struct lu_env *env,
2779                                struct dt_object *dt, struct lu_buf *buf,
2780                                const char *name)
2781 {
2782         LASSERT(dt);
2783         LASSERT(dt->do_ops);
2784         LASSERT(dt->do_ops->do_xattr_get);
2785
2786         if (CFS_FAULT_CHECK(OBD_FAIL_DT_XATTR_GET))
2787                 return cfs_fail_err;
2788
2789         return dt->do_ops->do_xattr_get(env, dt, buf, name);
2790 }
2791
2792 static inline int dt_xattr_list(const struct lu_env *env, struct dt_object *dt,
2793                                 const struct lu_buf *buf)
2794 {
2795         LASSERT(dt);
2796         LASSERT(dt->do_ops);
2797         LASSERT(dt->do_ops->do_xattr_list);
2798
2799         if (CFS_FAULT_CHECK(OBD_FAIL_DT_XATTR_LIST))
2800                 return cfs_fail_err;
2801
2802         return dt->do_ops->do_xattr_list(env, dt, buf);
2803 }
2804
2805 static inline int dt_invalidate(const struct lu_env *env, struct dt_object *dt)
2806 {
2807         LASSERT(dt);
2808         LASSERT(dt->do_ops);
2809         LASSERT(dt->do_ops->do_invalidate);
2810
2811         return dt->do_ops->do_invalidate(env, dt);
2812 }
2813
2814 static inline int dt_declare_delete(const struct lu_env *env,
2815                                     struct dt_object *dt,
2816                                     const struct dt_key *key,
2817                                     struct thandle *th)
2818 {
2819         LASSERT(dt);
2820         LASSERT(dt->do_index_ops);
2821         LASSERT(dt->do_index_ops->dio_declare_delete);
2822
2823         if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_DELETE))
2824                 return cfs_fail_err;
2825
2826         return dt->do_index_ops->dio_declare_delete(env, dt, key, th);
2827 }
2828
2829 static inline int dt_delete(const struct lu_env *env,
2830                             struct dt_object *dt,
2831                             const struct dt_key *key,
2832                             struct thandle *th)
2833 {
2834         LASSERT(dt);
2835         LASSERT(dt->do_index_ops);
2836         LASSERT(dt->do_index_ops->dio_delete);
2837
2838         if (CFS_FAULT_CHECK(OBD_FAIL_DT_DELETE))
2839                 return cfs_fail_err;
2840
2841         return dt->do_index_ops->dio_delete(env, dt, key, th);
2842 }
2843
2844 static inline int dt_commit_async(const struct lu_env *env,
2845                                   struct dt_device *dev)
2846 {
2847         LASSERT(dev);
2848         LASSERT(dev->dd_ops);
2849         LASSERT(dev->dd_ops->dt_commit_async);
2850         return dev->dd_ops->dt_commit_async(env, dev);
2851 }
2852
2853 static inline int dt_lookup(const struct lu_env *env,
2854                             struct dt_object *dt,
2855                             struct dt_rec *rec,
2856                             const struct dt_key *key)
2857 {
2858         int ret;
2859
2860         LASSERT(dt);
2861         LASSERT(dt->do_index_ops);
2862         LASSERT(dt->do_index_ops->dio_lookup);
2863
2864         if (CFS_FAULT_CHECK(OBD_FAIL_DT_LOOKUP))
2865                 return cfs_fail_err;
2866
2867         ret = dt->do_index_ops->dio_lookup(env, dt, rec, key);
2868         if (ret > 0)
2869                 ret = 0;
2870         else if (ret == 0)
2871                 ret = -ENOENT;
2872         return ret;
2873 }
2874
2875 static inline int dt_declare_layout_change(const struct lu_env *env,
2876                                            struct dt_object *o,
2877                                            struct md_layout_change *mlc,
2878                                            struct thandle *th)
2879 {
2880         LASSERT(o);
2881         LASSERT(o->do_ops);
2882         LASSERT(o->do_ops->do_declare_layout_change);
2883         return o->do_ops->do_declare_layout_change(env, o, mlc, th);
2884 }
2885
2886 static inline int dt_layout_change(const struct lu_env *env,
2887                                    struct dt_object *o,
2888                                    struct md_layout_change *mlc,
2889                                    struct thandle *th)
2890 {
2891         LASSERT(o);
2892         LASSERT(o->do_ops);
2893         LASSERT(o->do_ops->do_layout_change);
2894         return o->do_ops->do_layout_change(env, o, mlc, th);
2895 }
2896
2897 struct dt_find_hint {
2898         struct lu_fid        *dfh_fid;
2899         struct dt_device     *dfh_dt;
2900         struct dt_object     *dfh_o;
2901 };
2902
2903 struct dt_insert_rec {
2904         union {
2905                 const struct lu_fid     *rec_fid;
2906                 void                    *rec_data;
2907         };
2908         union {
2909                 struct {
2910                         __u32            rec_type;
2911                         __u32            rec_padding;
2912                 };
2913                 __u64                    rec_misc;
2914         };
2915 };
2916
2917 struct dt_thread_info {
2918         char                     dti_buf[DT_MAX_PATH];
2919         struct dt_find_hint      dti_dfh;
2920         struct lu_attr           dti_attr;
2921         struct lu_fid            dti_fid;
2922         struct dt_object_format  dti_dof;
2923         struct lustre_mdt_attrs  dti_lma;
2924         struct lu_buf            dti_lb;
2925         struct lu_object_conf    dti_conf;
2926         loff_t                   dti_off;
2927         struct dt_insert_rec     dti_dt_rec;
2928 };
2929
2930 extern struct lu_context_key dt_key;
2931
2932 static inline struct dt_thread_info *dt_info(const struct lu_env *env)
2933 {
2934         struct dt_thread_info *dti;
2935
2936         dti = lu_context_key_get(&env->le_ctx, &dt_key);
2937         LASSERT(dti);
2938         return dti;
2939 }
2940
2941 int dt_global_init(void);
2942 void dt_global_fini(void);
2943 int dt_tunables_init(struct dt_device *dt, struct obd_type *type,
2944                      const char *name, struct lprocfs_vars *list);
2945 int dt_tunables_fini(struct dt_device *dt);
2946
2947 # ifdef CONFIG_PROC_FS
2948 int lprocfs_dt_blksize_seq_show(struct seq_file *m, void *v);
2949 int lprocfs_dt_kbytestotal_seq_show(struct seq_file *m, void *v);
2950 int lprocfs_dt_kbytesfree_seq_show(struct seq_file *m, void *v);
2951 int lprocfs_dt_kbytesavail_seq_show(struct seq_file *m, void *v);
2952 int lprocfs_dt_filestotal_seq_show(struct seq_file *m, void *v);
2953 int lprocfs_dt_filesfree_seq_show(struct seq_file *m, void *v);
2954 # endif /* CONFIG_PROC_FS */
2955
2956 #endif /* __LUSTRE_DT_OBJECT_H */