daos_fs.h

Go to the documentation of this file.

/*
 * (C) Copyright 2018-2024 Intel Corporation.
 *
 * SPDX-License-Identifier: BSD-2-Clause-Patent
 */
#ifndef __DAOS_FS_H__
#define __DAOS_FS_H__
 
#if defined(__cplusplus)
extern "C" {
#endif
 
#include <dirent.h>
#include <inttypes.h>
#include <sys/stat.h>
 
#include <daos_types.h>
#include <daos_obj.h>
#include <daos_obj_class.h>
#include <daos_array.h>
#include <daos_cont.h>
 
#define DFS_MAX_NAME        NAME_MAX
#define DFS_MAX_PATH        PATH_MAX
#define DFS_MAX_FSIZE       (~0ULL)
#define DFS_DEFAULT_CHUNK_SIZE  1048576
#define DFS_MAX_XATTR_NAME  255
#define DFS_MAX_XATTR_LEN   65536
 
typedef struct dfs_obj dfs_obj_t;
typedef struct dfs dfs_t;
 
/*
 * Consistency modes of the DFS container. A container created with balanced
 * mode, can only be accessed with balanced mode with dfs_mount. A container
 * created with relaxed mode, can be accessed with either mode in the future.
 *
 * Reserve bit 3 in the access flags for dfs_mount() - bits 1 and 2 are used
 * for read / write access (O_RDONLY, O_RDRW).
 */
#define DFS_BALANCED    4
#define DFS_RELAXED 0
#define DFS_RDONLY  O_RDONLY
#define DFS_RDWR    O_RDWR
 
typedef struct {
    uint64_t        da_id;
    daos_size_t     da_chunk_size;
    daos_oclass_id_t    da_oclass_id;
    daos_prop_t     *da_props;
    uint32_t        da_mode;
    daos_oclass_id_t    da_dir_oclass_id;
    daos_oclass_id_t    da_file_oclass_id;
    char            da_hints[DAOS_CONT_HINT_MAX_LEN];
} dfs_attr_t;
 
typedef struct {
    daos_size_t     iod_nr;
    daos_range_t           *iod_rgs;
} dfs_iod_t;
 
typedef struct {
    daos_oclass_id_t    doi_oclass_id;
    daos_size_t     doi_chunk_size;
    daos_oclass_id_t        doi_dir_oclass_id;
    daos_oclass_id_t        doi_file_oclass_id;
    daos_obj_id_t           doi_oid;
} dfs_obj_info_t;
 
int
dfs_init(void);
 
int
dfs_fini(void);
 
int
dfs_connect(const char *pool, const char *sys, const char *cont, int flags, dfs_attr_t *attr,
        dfs_t **dfs);
 
int
dfs_disconnect(dfs_t *dfs);
 
int
dfs_destroy(const char *pool, const char *sys, const char *cont, int force, daos_event_t *ev);
 
int
dfs_cont_create(daos_handle_t poh, uuid_t *uuid, dfs_attr_t *attr, daos_handle_t *coh, dfs_t **dfs);
 
int
dfs_cont_create_with_label(daos_handle_t poh, const char *label, dfs_attr_t *attr,
               uuid_t *uuid, daos_handle_t *coh, dfs_t **dfs);
 
int
dfs_mount(daos_handle_t poh, daos_handle_t coh, int flags, dfs_t **dfs);
 
int
dfs_umount(dfs_t *dfs);
 
int
dfs_pool_get(dfs_t *dfs, daos_handle_t *poh);
 
int
dfs_pool_put(dfs_t *dfs, daos_handle_t poh);
 
int
dfs_cont_get(dfs_t *dfs, daos_handle_t *coh);
 
int
dfs_cont_put(dfs_t *dfs, daos_handle_t coh);
 
int
dfs_query(dfs_t *dfs, dfs_attr_t *attr);
 
int
dfs_local2global(dfs_t *dfs, d_iov_t *glob);
 
int
dfs_global2local(daos_handle_t poh, daos_handle_t coh, int flags, d_iov_t glob,
         dfs_t **dfs);
 
int
dfs_local2global_all(dfs_t *dfs, d_iov_t *glob);
 
int
dfs_global2local_all(int flags, d_iov_t glob, dfs_t **dfs);
 
int
dfs_set_prefix(dfs_t *dfs, const char *prefix);
 
int
dfs_obj2id(dfs_obj_t *obj, daos_obj_id_t *oid);
 
int
dfs_lookup(dfs_t *dfs, const char *path, int flags, dfs_obj_t **obj,
       mode_t *mode, struct stat *stbuf);
 
int
dfs_lookup_rel(dfs_t *dfs, dfs_obj_t *parent, const char *name, int flags,
           dfs_obj_t **obj, mode_t *mode, struct stat *stbuf);
 
int
dfs_suggest_oclass(dfs_t *dfs, const char *hint, daos_oclass_id_t *cid);
 
int
dfs_open(dfs_t *dfs, dfs_obj_t *parent, const char *name, mode_t mode,
     int flags, daos_oclass_id_t cid, daos_size_t chunk_size,
     const char *value, dfs_obj_t **obj);
 
int
dfs_dup(dfs_t *dfs, dfs_obj_t *obj, int flags, dfs_obj_t **new_obj);
 
int
dfs_obj_local2global(dfs_t *dfs, dfs_obj_t *obj, d_iov_t *glob);
 
int
dfs_obj_global2local(dfs_t *dfs, int flags, d_iov_t glob, dfs_obj_t **obj);
 
int
dfs_release(dfs_obj_t *obj);
 
int
dfs_read(dfs_t *dfs, dfs_obj_t *obj, d_sg_list_t *sgl, daos_off_t off,
     daos_size_t *read_size, daos_event_t *ev);
 
int
dfs_readx(dfs_t *dfs, dfs_obj_t *obj, dfs_iod_t *iod, d_sg_list_t *sgl,
      daos_size_t *read_size, daos_event_t *ev);
 
int
dfs_write(dfs_t *dfs, dfs_obj_t *obj, d_sg_list_t *sgl, daos_off_t off,
      daos_event_t *ev);
 
int
dfs_writex(dfs_t *dfs, dfs_obj_t *obj, dfs_iod_t *iod, d_sg_list_t *sgl,
       daos_event_t *ev);
 
int
dfs_get_size(dfs_t *dfs, dfs_obj_t *obj, daos_size_t *size);
 
int
dfs_punch(dfs_t *dfs, dfs_obj_t *obj, daos_off_t offset, daos_size_t len);
 
int
dfs_readdir(dfs_t *dfs, dfs_obj_t *obj, daos_anchor_t *anchor, uint32_t *nr, struct dirent *dirs);
 
int
dfs_readdirplus(dfs_t *dfs, dfs_obj_t *obj, daos_anchor_t *anchor, uint32_t *nr,
        struct dirent *dirs, struct stat *stbufs);
 
typedef int (*dfs_filler_cb_t)(dfs_t *dfs, dfs_obj_t *obj, const char name[], void *arg);
 
int
dfs_iterate(dfs_t *dfs, dfs_obj_t *obj, daos_anchor_t *anchor,
        uint32_t *nr, size_t size, dfs_filler_cb_t op, void *arg);
 
int
dfs_dir_anchor_set(dfs_obj_t *obj, const char name[], daos_anchor_t *anchor);
 
int
dfs_obj_anchor_split(dfs_obj_t *obj, uint32_t *nr, daos_anchor_t *anchors);
 
int
dfs_obj_anchor_set(dfs_obj_t *obj, uint32_t index, daos_anchor_t *anchor);
 
int
dfs_mkdir(dfs_t *dfs, dfs_obj_t *parent, const char *name, mode_t mode,
      daos_oclass_id_t cid);
 
int
dfs_remove(dfs_t *dfs, dfs_obj_t *parent, const char *name, bool force,
       daos_obj_id_t *oid);
 
int
dfs_move(dfs_t *dfs, dfs_obj_t *parent, const char *name, dfs_obj_t *new_parent,
     const char *new_name, daos_obj_id_t *oid);
 
int
dfs_exchange(dfs_t *dfs, dfs_obj_t *parent1, const char *name1, dfs_obj_t *parent2,
         const char *name2);
 
int
dfs_get_mode(dfs_obj_t *obj, mode_t *mode);
 
int
dfs_obj_get_info(dfs_t *dfs, dfs_obj_t *obj, dfs_obj_info_t *info);
 
int
dfs_obj_set_oclass(dfs_t *dfs, dfs_obj_t *obj, int flags, daos_oclass_id_t cid);
 
int
dfs_obj_set_chunk_size(dfs_t *dfs, dfs_obj_t *obj, int flags, daos_size_t csize);
 
int
dfs_get_file_oh(dfs_obj_t *obj, daos_handle_t *oh);
 
int
dfs_get_chunk_size(dfs_obj_t *obj, daos_size_t *chunk_size);
 
int
dfs_get_symlink_value(dfs_obj_t *obj, char *buf, daos_size_t *size);
 
int
dfs_update_parent(dfs_obj_t *obj, dfs_obj_t *src_obj, const char *name);
 
int
dfs_stat(dfs_t *dfs, dfs_obj_t *parent, const char *name,
     struct stat *stbuf);
 
int
dfs_ostat(dfs_t *dfs, dfs_obj_t *obj, struct stat *stbuf);
 
#define DFS_SET_ATTR_MODE   (1 << 0)
#define DFS_SET_ATTR_ATIME  (1 << 1)
#define DFS_SET_ATTR_MTIME  (1 << 2)
#define DFS_SET_ATTR_SIZE   (1 << 3)
#define DFS_SET_ATTR_UID    (1 << 4)
#define DFS_SET_ATTR_GID    (1 << 5)
 
int
dfs_osetattr(dfs_t *dfs, dfs_obj_t *obj, struct stat *stbuf, int flags);
 
int
dfs_access(dfs_t *dfs, dfs_obj_t *parent, const char *name, int mask);
 
int
dfs_chmod(dfs_t *dfs, dfs_obj_t *parent, const char *name, mode_t mode);
 
int
dfs_chown(dfs_t *dfs, dfs_obj_t *parent, const char *name, uid_t uid, gid_t gid, int flags);
 
int
dfs_sync(dfs_t *dfs);
 
int
dfs_setxattr(dfs_t *dfs, dfs_obj_t *obj, const char *name,
         const void *value, daos_size_t size, int flags);
 
int
dfs_getxattr(dfs_t *dfs, dfs_obj_t *obj, const char *name, void *value,
         daos_size_t *size);
 
int
dfs_removexattr(dfs_t *dfs, dfs_obj_t *obj, const char *name);
 
int
dfs_listxattr(dfs_t *dfs, dfs_obj_t *obj, char *list, daos_size_t *size);
 
 
enum {
    DFS_CHECK_PRINT     = (1 << 0),
    DFS_CHECK_REMOVE    = (1 << 1),
    DFS_CHECK_RELINK    = (1 << 2),
    DFS_CHECK_VERIFY    = (1 << 3),
    DFS_CHECK_EVICT_ALL = (1 << 4),
};
 
int
dfs_cont_check(daos_handle_t poh, const char *cont, uint64_t flags, const char *name);
 
int
dfs_cont_set_owner(daos_handle_t coh, d_string_t user, uid_t uid, d_string_t group, gid_t gid);
 
/*
 * The Pipeline DFS API (everything under this comment) is under heavy development and should not be
 * used in production. The API is subject to change.
 */
 
typedef struct dfs_pipeline dfs_pipeline_t;
 
enum {
    DFS_FILTER_NAME     = (1 << 1),
    DFS_FILTER_NEWER    = (1 << 2),
    DFS_FILTER_INCLUDE_DIRS = (1 << 3),
};
 
typedef struct {
    char    dp_name[DFS_MAX_NAME];
    time_t  dp_newer;
    size_t  dp_size;
} dfs_predicate_t;
 
int
dfs_get_size_by_oid(dfs_t *dfs, daos_obj_id_t oid, daos_size_t chunk_size, daos_size_t *size);
 
int
dfs_pipeline_create(dfs_t *dfs, dfs_predicate_t pred, uint64_t flags, dfs_pipeline_t **dpipe);
 
int
dfs_pipeline_destroy(dfs_pipeline_t *dpipe);
 
int
dfs_readdir_with_filter(dfs_t *dfs, dfs_obj_t *obj, dfs_pipeline_t *dpipe, daos_anchor_t *anchor,
            uint32_t *nr, struct dirent *dirs, daos_obj_id_t *oids, daos_size_t *csizes,
            uint64_t *nr_scanned);
 
int
dfs_cont_scan(daos_handle_t poh, const char *cont, uint64_t flags, const char *name);
 
#if defined(__cplusplus)
}
#endif /* __cplusplus */
#endif /* __DAOS_FS_H__ */