git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs.h

   1 #ifndef _LIBBCACHE_H
   2 #define _LIBBCACHE_H
   3
   4 #include <linux/uuid.h>
   5 #include <stdbool.h>
   6
   7 #include "libbcachefs/bcachefs_format.h"
   8 #include "libbcachefs/bcachefs_ioctl.h"
   9 #include "libbcachefs/opts.h"
  10 #include "libbcachefs/vstructs.h"
  11 #include "tools-util.h"
  12
  13 /* option parsing */
  14
  15 struct bch_opt_strs {
  16 union {
  17         char                    *by_id[bch2_opts_nr];
  18 struct {
  19 #define x(_name, ...)   char    *_name;
  20         BCH_OPTS()
  21 #undef x
  22 };
  23 };
  24 };
  25
  26 struct bch_opt_strs bch2_cmdline_opts_get(int *, char *[], unsigned);
  27 struct bch_opts bch2_parse_opts(struct bch_opt_strs);
  28 void bch2_opts_usage(unsigned);
  29
  30 struct format_opts {
  31         char            *label;
  32         uuid_le         uuid;
  33         unsigned        version;
  34
  35         unsigned        encoded_extent_max;
  36
  37         bool            encrypted;
  38         char            *passphrase;
  39 };
  40
  41 static inline struct format_opts format_opts_default()
  42 {
  43         return (struct format_opts) {
  44                 .version                = bcachefs_metadata_version_current,
  45                 .encoded_extent_max     = 128,
  46         };
  47 }
  48
  49 struct dev_opts {
  50         int             fd;
  51         char            *path;
  52         u64             size; /* 512 byte sectors */
  53         unsigned        bucket_size;
  54         const char      *group;
  55         unsigned        data_allowed;
  56         unsigned        durability;
  57         bool            discard;
  58
  59         u64             nbuckets;
  60
  61         u64             sb_offset;
  62         u64             sb_end;
  63 };
  64
  65 static inline struct dev_opts dev_opts_default()
  66 {
  67         return (struct dev_opts) {
  68                 .data_allowed           = ~0U << 2,
  69                 .durability             = 1,
  70         };
  71 }
  72
  73 void bch2_pick_bucket_size(struct bch_opts, struct dev_opts *);
  74 struct bch_sb *bch2_format(struct bch_opt_strs,
  75                            struct bch_opts,
  76                            struct format_opts, struct dev_opts *, size_t);
  77
  78 void bch2_super_write(int, struct bch_sb *);
  79 struct bch_sb *__bch2_super_read(int, u64);
  80
  81 void bch2_sb_print(struct bch_sb *, bool, unsigned, enum units);
  82
  83 /* ioctl interface: */
  84
  85 int bcachectl_open(void);
  86
  87 struct bchfs_handle {
  88         uuid_le uuid;
  89         int     ioctl_fd;
  90         int     sysfs_fd;
  91 };
  92
  93 void bcache_fs_close(struct bchfs_handle);
  94 struct bchfs_handle bcache_fs_open(const char *);
  95 struct bchfs_handle bchu_fs_open_by_dev(const char *, unsigned *);
  96
  97 static inline void bchu_disk_add(struct bchfs_handle fs, char *dev)
  98 {
  99         struct bch_ioctl_disk i = { .dev = (unsigned long) dev, };
 100
 101         xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_ADD, &i);
 102 }
 103
 104 static inline void bchu_disk_remove(struct bchfs_handle fs, unsigned dev_idx,
 105                                     unsigned flags)
 106 {
 107         struct bch_ioctl_disk i = {
 108                 .flags  = flags|BCH_BY_INDEX,
 109                 .dev    = dev_idx,
 110         };
 111
 112         xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_REMOVE, &i);
 113 }
 114
 115 static inline void bchu_disk_online(struct bchfs_handle fs, char *dev)
 116 {
 117         struct bch_ioctl_disk i = { .dev = (unsigned long) dev, };
 118
 119         xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_ONLINE, &i);
 120 }
 121
 122 static inline void bchu_disk_offline(struct bchfs_handle fs, unsigned dev_idx,
 123                                      unsigned flags)
 124 {
 125         struct bch_ioctl_disk i = {
 126                 .flags  = flags|BCH_BY_INDEX,
 127                 .dev    = dev_idx,
 128         };
 129
 130         xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_OFFLINE, &i);
 131 }
 132
 133 static inline void bchu_disk_set_state(struct bchfs_handle fs, unsigned dev,
 134                                        unsigned new_state, unsigned flags)
 135 {
 136         struct bch_ioctl_disk_set_state i = {
 137                 .flags          = flags|BCH_BY_INDEX,
 138                 .new_state      = new_state,
 139                 .dev            = dev,
 140         };
 141
 142         xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_SET_STATE, &i);
 143 }
 144
 145 static inline struct bch_ioctl_fs_usage *bchu_fs_usage(struct bchfs_handle fs)
 146 {
 147         struct bch_ioctl_fs_usage *u = NULL;
 148         size_t replica_entries_bytes = 4096;
 149
 150         while (1) {
 151                 u = xrealloc(u, sizeof(*u) + replica_entries_bytes);
 152                 u->replica_entries_bytes = replica_entries_bytes;
 153
 154                 if (!ioctl(fs.ioctl_fd, BCH_IOCTL_FS_USAGE, u))
 155                         return u;
 156
 157                 if (errno != ERANGE)
 158                         die("BCH_IOCTL_USAGE error: %m");
 159
 160                 replica_entries_bytes *= 2;
 161         }
 162 }
 163
 164 static inline struct bch_ioctl_dev_usage bchu_dev_usage(struct bchfs_handle fs,
 165                                                         unsigned idx)
 166 {
 167         struct bch_ioctl_dev_usage i = { .dev = idx, .flags = BCH_BY_INDEX};
 168
 169         if (xioctl(fs.ioctl_fd, BCH_IOCTL_DEV_USAGE, &i))
 170                 die("BCH_IOCTL_DEV_USAGE error: %m");
 171         return i;
 172 }
 173
 174 static inline struct bch_sb *bchu_read_super(struct bchfs_handle fs, unsigned idx)
 175 {
 176         size_t size = 4096;
 177         struct bch_sb *sb = NULL;
 178
 179         while (1) {
 180                 sb = xrealloc(sb, size);
 181                 struct bch_ioctl_read_super i = {
 182                         .size   = size,
 183                         .sb     = (unsigned long) sb,
 184                 };
 185
 186                 if (idx != -1) {
 187                         i.flags |= BCH_READ_DEV|BCH_BY_INDEX;
 188                         i.dev = idx;
 189                 }
 190
 191                 if (!ioctl(fs.ioctl_fd, BCH_IOCTL_READ_SUPER, &i))
 192                         return sb;
 193                 if (errno != ERANGE)
 194                         die("BCH_IOCTL_READ_SUPER error: %m");
 195                 size *= 2;
 196         }
 197 }
 198
 199 static inline unsigned bchu_disk_get_idx(struct bchfs_handle fs, dev_t dev)
 200 {
 201         struct bch_ioctl_disk_get_idx i = { .dev = dev };
 202
 203         return xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_GET_IDX, &i);
 204 }
 205
 206 static inline void bchu_disk_resize(struct bchfs_handle fs,
 207                                     unsigned idx,
 208                                     u64 nbuckets)
 209 {
 210         struct bch_ioctl_disk_resize i = {
 211                 .flags  = BCH_BY_INDEX,
 212                 .dev    = idx,
 213                 .nbuckets = nbuckets,
 214         };
 215
 216         xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_RESIZE, &i);
 217 }
 218
 219 static inline void bchu_disk_resize_journal(struct bchfs_handle fs,
 220                                             unsigned idx,
 221                                             u64 nbuckets)
 222 {
 223         struct bch_ioctl_disk_resize i = {
 224                 .flags  = BCH_BY_INDEX,
 225                 .dev    = idx,
 226                 .nbuckets = nbuckets,
 227         };
 228
 229         xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_RESIZE_JOURNAL, &i);
 230 }
 231
 232 int bchu_data(struct bchfs_handle, struct bch_ioctl_data);
 233
 234 struct dev_name {
 235         unsigned        idx;
 236         char            *dev;
 237         char            *label;
 238         uuid_le         uuid;
 239 };
 240 typedef darray(struct dev_name) dev_names;
 241
 242 dev_names bchu_fs_get_devices(struct bchfs_handle);
 243
 244 #endif /* _LIBBCACHE_H */