fs/btrfs/accessors.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2
   3 #ifndef BTRFS_ACCESSORS_H
   4 #define BTRFS_ACCESSORS_H
   5
   6 #include <linux/stddef.h>
   7 #include <asm/unaligned.h>
   8
   9 struct btrfs_map_token {
  10         struct extent_buffer *eb;
  11         char *kaddr;
  12         unsigned long offset;
  13 };
  14
  15 void btrfs_init_map_token(struct btrfs_map_token *token, struct extent_buffer *eb);
  16
  17 /*
  18  * Some macros to generate set/get functions for the struct fields.  This
  19  * assumes there is a lefoo_to_cpu for every type, so lets make a simple one
  20  * for u8:
  21  */
  22 #define le8_to_cpu(v) (v)
  23 #define cpu_to_le8(v) (v)
  24 #define __le8 u8
  25
  26 static inline u8 get_unaligned_le8(const void *p)
  27 {
  28        return *(u8 *)p;
  29 }
  30
  31 static inline void put_unaligned_le8(u8 val, void *p)
  32 {
  33        *(u8 *)p = val;
  34 }
  35
  36 #define read_eb_member(eb, ptr, type, member, result) (\
  37         read_extent_buffer(eb, (char *)(result),                        \
  38                            ((unsigned long)(ptr)) +                     \
  39                             offsetof(type, member),                     \
  40                             sizeof_field(type, member)))
  41
  42 #define write_eb_member(eb, ptr, type, member, result) (\
  43         write_extent_buffer(eb, (char *)(result),                       \
  44                            ((unsigned long)(ptr)) +                     \
  45                             offsetof(type, member),                     \
  46                             sizeof_field(type, member)))
  47
  48 #define DECLARE_BTRFS_SETGET_BITS(bits)                                 \
  49 u##bits btrfs_get_token_##bits(struct btrfs_map_token *token,           \
  50                                const void *ptr, unsigned long off);     \
  51 void btrfs_set_token_##bits(struct btrfs_map_token *token,              \
  52                             const void *ptr, unsigned long off,         \
  53                             u##bits val);                               \
  54 u##bits btrfs_get_##bits(const struct extent_buffer *eb,                \
  55                          const void *ptr, unsigned long off);           \
  56 void btrfs_set_##bits(const struct extent_buffer *eb, void *ptr,        \
  57                       unsigned long off, u##bits val);
  58
  59 DECLARE_BTRFS_SETGET_BITS(8)
  60 DECLARE_BTRFS_SETGET_BITS(16)
  61 DECLARE_BTRFS_SETGET_BITS(32)
  62 DECLARE_BTRFS_SETGET_BITS(64)
  63
  64 #define BTRFS_SETGET_FUNCS(name, type, member, bits)                    \
  65 static inline u##bits btrfs_##name(const struct extent_buffer *eb,      \
  66                                    const type *s)                       \
  67 {                                                                       \
  68         static_assert(sizeof(u##bits) == sizeof_field(type, member));   \
  69         return btrfs_get_##bits(eb, s, offsetof(type, member));         \
  70 }                                                                       \
  71 static inline void btrfs_set_##name(const struct extent_buffer *eb, type *s, \
  72                                     u##bits val)                        \
  73 {                                                                       \
  74         static_assert(sizeof(u##bits) == sizeof_field(type, member));   \
  75         btrfs_set_##bits(eb, s, offsetof(type, member), val);           \
  76 }                                                                       \
  77 static inline u##bits btrfs_token_##name(struct btrfs_map_token *token, \
  78                                          const type *s)                 \
  79 {                                                                       \
  80         static_assert(sizeof(u##bits) == sizeof_field(type, member));   \
  81         return btrfs_get_token_##bits(token, s, offsetof(type, member));\
  82 }                                                                       \
  83 static inline void btrfs_set_token_##name(struct btrfs_map_token *token,\
  84                                           type *s, u##bits val)         \
  85 {                                                                       \
  86         static_assert(sizeof(u##bits) == sizeof_field(type, member));   \
  87         btrfs_set_token_##bits(token, s, offsetof(type, member), val);  \
  88 }
  89
  90 #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits)             \
  91 static inline u##bits btrfs_##name(const struct extent_buffer *eb)      \
  92 {                                                                       \
  93         const type *p = page_address(eb->pages[0]) +                    \
  94                         offset_in_page(eb->start);                      \
  95         return get_unaligned_le##bits(&p->member);                      \
  96 }                                                                       \
  97 static inline void btrfs_set_##name(const struct extent_buffer *eb,     \
  98                                     u##bits val)                        \
  99 {                                                                       \
 100         type *p = page_address(eb->pages[0]) + offset_in_page(eb->start); \
 101         put_unaligned_le##bits(val, &p->member);                        \
 102 }
 103
 104 #define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits)              \
 105 static inline u##bits btrfs_##name(const type *s)                       \
 106 {                                                                       \
 107         return get_unaligned_le##bits(&s->member);                      \
 108 }                                                                       \
 109 static inline void btrfs_set_##name(type *s, u##bits val)               \
 110 {                                                                       \
 111         put_unaligned_le##bits(val, &s->member);                        \
 112 }
 113
 114 static inline u64 btrfs_device_total_bytes(const struct extent_buffer *eb,
 115                                            struct btrfs_dev_item *s)
 116 {
 117         static_assert(sizeof(u64) == sizeof_field(struct btrfs_dev_item, total_bytes));
 118         return btrfs_get_64(eb, s, offsetof(struct btrfs_dev_item, total_bytes));
 119 }
 120 static inline void btrfs_set_device_total_bytes(const struct extent_buffer *eb,
 121                                                 struct btrfs_dev_item *s,
 122                                                 u64 val)
 123 {
 124         static_assert(sizeof(u64) == sizeof_field(struct btrfs_dev_item, total_bytes));
 125         WARN_ON(!IS_ALIGNED(val, eb->fs_info->sectorsize));
 126         btrfs_set_64(eb, s, offsetof(struct btrfs_dev_item, total_bytes), val);
 127 }
 128
 129 BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
 130 BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
 131 BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
 132 BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
 133 BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item, start_offset, 64);
 134 BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
 135 BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
 136 BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
 137 BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
 138 BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
 139 BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
 140
 141 BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
 142 BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
 143                          total_bytes, 64);
 144 BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
 145                          bytes_used, 64);
 146 BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
 147                          io_align, 32);
 148 BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
 149                          io_width, 32);
 150 BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
 151                          sector_size, 32);
 152 BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
 153 BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item, dev_group, 32);
 154 BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
 155                          seek_speed, 8);
 156 BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
 157                          bandwidth, 8);
 158 BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
 159                          generation, 64);
 160
 161 static inline unsigned long btrfs_device_uuid(struct btrfs_dev_item *d)
 162 {
 163         return (unsigned long)d + offsetof(struct btrfs_dev_item, uuid);
 164 }
 165
 166 static inline unsigned long btrfs_device_fsid(struct btrfs_dev_item *d)
 167 {
 168         return (unsigned long)d + offsetof(struct btrfs_dev_item, fsid);
 169 }
 170
 171 BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
 172 BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
 173 BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
 174 BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
 175 BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
 176 BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
 177 BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
 178 BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
 179 BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
 180 BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
 181 BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
 182
 183 static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
 184 {
 185         return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
 186 }
 187
 188 BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
 189 BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
 190 BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
 191                          stripe_len, 64);
 192 BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk, io_align, 32);
 193 BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk, io_width, 32);
 194 BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
 195                          sector_size, 32);
 196 BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
 197 BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
 198                          num_stripes, 16);
 199 BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
 200                          sub_stripes, 16);
 201 BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
 202 BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
 203
 204 static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c, int nr)
 205 {
 206         unsigned long offset = (unsigned long)c;
 207
 208         offset += offsetof(struct btrfs_chunk, stripe);
 209         offset += nr * sizeof(struct btrfs_stripe);
 210         return (struct btrfs_stripe *)offset;
 211 }
 212
 213 static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
 214 {
 215         return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
 216 }
 217
 218 static inline u64 btrfs_stripe_offset_nr(const struct extent_buffer *eb,
 219                                          struct btrfs_chunk *c, int nr)
 220 {
 221         return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
 222 }
 223
 224 static inline void btrfs_set_stripe_offset_nr(struct extent_buffer *eb,
 225                                               struct btrfs_chunk *c, int nr,
 226                                               u64 val)
 227 {
 228         btrfs_set_stripe_offset(eb, btrfs_stripe_nr(c, nr), val);
 229 }
 230
 231 static inline u64 btrfs_stripe_devid_nr(const struct extent_buffer *eb,
 232                                          struct btrfs_chunk *c, int nr)
 233 {
 234         return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
 235 }
 236
 237 static inline void btrfs_set_stripe_devid_nr(struct extent_buffer *eb,
 238                                              struct btrfs_chunk *c, int nr,
 239                                              u64 val)
 240 {
 241         btrfs_set_stripe_devid(eb, btrfs_stripe_nr(c, nr), val);
 242 }
 243
 244 /* struct btrfs_block_group_item */
 245 BTRFS_SETGET_STACK_FUNCS(stack_block_group_used, struct btrfs_block_group_item,
 246                          used, 64);
 247 BTRFS_SETGET_FUNCS(block_group_used, struct btrfs_block_group_item, used, 64);
 248 BTRFS_SETGET_STACK_FUNCS(stack_block_group_chunk_objectid,
 249                         struct btrfs_block_group_item, chunk_objectid, 64);
 250
 251 BTRFS_SETGET_FUNCS(block_group_chunk_objectid,
 252                    struct btrfs_block_group_item, chunk_objectid, 64);
 253 BTRFS_SETGET_FUNCS(block_group_flags, struct btrfs_block_group_item, flags, 64);
 254 BTRFS_SETGET_STACK_FUNCS(stack_block_group_flags,
 255                         struct btrfs_block_group_item, flags, 64);
 256
 257 /* struct btrfs_free_space_info */
 258 BTRFS_SETGET_FUNCS(free_space_extent_count, struct btrfs_free_space_info,
 259                    extent_count, 32);
 260 BTRFS_SETGET_FUNCS(free_space_flags, struct btrfs_free_space_info, flags, 32);
 261
 262 /* struct btrfs_inode_ref */
 263 BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
 264 BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
 265 BTRFS_SETGET_STACK_FUNCS(stack_inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
 266 BTRFS_SETGET_STACK_FUNCS(stack_inode_ref_index, struct btrfs_inode_ref, index, 64);
 267
 268 /* struct btrfs_inode_extref */
 269 BTRFS_SETGET_FUNCS(inode_extref_parent, struct btrfs_inode_extref,
 270                    parent_objectid, 64);
 271 BTRFS_SETGET_FUNCS(inode_extref_name_len, struct btrfs_inode_extref,
 272                    name_len, 16);
 273 BTRFS_SETGET_FUNCS(inode_extref_index, struct btrfs_inode_extref, index, 64);
 274
 275 /* struct btrfs_inode_item */
 276 BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
 277 BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
 278 BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
 279 BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
 280 BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
 281 BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
 282 BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
 283 BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
 284 BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
 285 BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
 286 BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
 287 BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
 288 BTRFS_SETGET_STACK_FUNCS(stack_inode_generation, struct btrfs_inode_item,
 289                          generation, 64);
 290 BTRFS_SETGET_STACK_FUNCS(stack_inode_sequence, struct btrfs_inode_item,
 291                          sequence, 64);
 292 BTRFS_SETGET_STACK_FUNCS(stack_inode_transid, struct btrfs_inode_item,
 293                          transid, 64);
 294 BTRFS_SETGET_STACK_FUNCS(stack_inode_size, struct btrfs_inode_item, size, 64);
 295 BTRFS_SETGET_STACK_FUNCS(stack_inode_nbytes, struct btrfs_inode_item, nbytes, 64);
 296 BTRFS_SETGET_STACK_FUNCS(stack_inode_block_group, struct btrfs_inode_item,
 297                          block_group, 64);
 298 BTRFS_SETGET_STACK_FUNCS(stack_inode_nlink, struct btrfs_inode_item, nlink, 32);
 299 BTRFS_SETGET_STACK_FUNCS(stack_inode_uid, struct btrfs_inode_item, uid, 32);
 300 BTRFS_SETGET_STACK_FUNCS(stack_inode_gid, struct btrfs_inode_item, gid, 32);
 301 BTRFS_SETGET_STACK_FUNCS(stack_inode_mode, struct btrfs_inode_item, mode, 32);
 302 BTRFS_SETGET_STACK_FUNCS(stack_inode_rdev, struct btrfs_inode_item, rdev, 64);
 303 BTRFS_SETGET_STACK_FUNCS(stack_inode_flags, struct btrfs_inode_item, flags, 64);
 304 BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
 305 BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
 306 BTRFS_SETGET_STACK_FUNCS(stack_timespec_sec, struct btrfs_timespec, sec, 64);
 307 BTRFS_SETGET_STACK_FUNCS(stack_timespec_nsec, struct btrfs_timespec, nsec, 32);
 308
 309 BTRFS_SETGET_FUNCS(stripe_extent_encoding, struct btrfs_stripe_extent, encoding, 8);
 310 BTRFS_SETGET_FUNCS(raid_stride_devid, struct btrfs_raid_stride, devid, 64);
 311 BTRFS_SETGET_FUNCS(raid_stride_physical, struct btrfs_raid_stride, physical, 64);
 312 BTRFS_SETGET_STACK_FUNCS(stack_stripe_extent_encoding,
 313                          struct btrfs_stripe_extent, encoding, 8);
 314 BTRFS_SETGET_STACK_FUNCS(stack_raid_stride_devid, struct btrfs_raid_stride, devid, 64);
 315 BTRFS_SETGET_STACK_FUNCS(stack_raid_stride_physical, struct btrfs_raid_stride, physical, 64);
 316
 317 /* struct btrfs_dev_extent */
 318 BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent, chunk_tree, 64);
 319 BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
 320                    chunk_objectid, 64);
 321 BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
 322                    chunk_offset, 64);
 323 BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
 324 BTRFS_SETGET_STACK_FUNCS(stack_dev_extent_chunk_tree, struct btrfs_dev_extent,
 325                          chunk_tree, 64);
 326 BTRFS_SETGET_STACK_FUNCS(stack_dev_extent_chunk_objectid, struct btrfs_dev_extent,
 327                          chunk_objectid, 64);
 328 BTRFS_SETGET_STACK_FUNCS(stack_dev_extent_chunk_offset, struct btrfs_dev_extent,
 329                          chunk_offset, 64);
 330 BTRFS_SETGET_STACK_FUNCS(stack_dev_extent_length, struct btrfs_dev_extent, length, 64);
 331
 332 BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
 333 BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item, generation, 64);
 334 BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
 335
 336 BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
 337
 338 static inline void btrfs_tree_block_key(const struct extent_buffer *eb,
 339                                         struct btrfs_tree_block_info *item,
 340                                         struct btrfs_disk_key *key)
 341 {
 342         read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
 343 }
 344
 345 static inline void btrfs_set_tree_block_key(const struct extent_buffer *eb,
 346                                             struct btrfs_tree_block_info *item,
 347                                             struct btrfs_disk_key *key)
 348 {
 349         write_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
 350 }
 351
 352 BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref, root, 64);
 353 BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
 354                    objectid, 64);
 355 BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
 356                    offset, 64);
 357 BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref, count, 32);
 358
 359 BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref, count, 32);
 360
 361 BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
 362                    type, 8);
 363 BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
 364                    offset, 64);
 365
 366 static inline u32 btrfs_extent_inline_ref_size(int type)
 367 {
 368         if (type == BTRFS_TREE_BLOCK_REF_KEY ||
 369             type == BTRFS_SHARED_BLOCK_REF_KEY)
 370                 return sizeof(struct btrfs_extent_inline_ref);
 371         if (type == BTRFS_SHARED_DATA_REF_KEY)
 372                 return sizeof(struct btrfs_shared_data_ref) +
 373                        sizeof(struct btrfs_extent_inline_ref);
 374         if (type == BTRFS_EXTENT_DATA_REF_KEY)
 375                 return sizeof(struct btrfs_extent_data_ref) +
 376                        offsetof(struct btrfs_extent_inline_ref, offset);
 377         return 0;
 378 }
 379
 380 /* struct btrfs_node */
 381 BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
 382 BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
 383 BTRFS_SETGET_STACK_FUNCS(stack_key_blockptr, struct btrfs_key_ptr, blockptr, 64);
 384 BTRFS_SETGET_STACK_FUNCS(stack_key_generation, struct btrfs_key_ptr,
 385                          generation, 64);
 386
 387 static inline u64 btrfs_node_blockptr(const struct extent_buffer *eb, int nr)
 388 {
 389         unsigned long ptr;
 390
 391         ptr = offsetof(struct btrfs_node, ptrs) +
 392                 sizeof(struct btrfs_key_ptr) * nr;
 393         return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
 394 }
 395
 396 static inline void btrfs_set_node_blockptr(const struct extent_buffer *eb,
 397                                            int nr, u64 val)
 398 {
 399         unsigned long ptr;
 400
 401         ptr = offsetof(struct btrfs_node, ptrs) +
 402                 sizeof(struct btrfs_key_ptr) * nr;
 403         btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
 404 }
 405
 406 static inline u64 btrfs_node_ptr_generation(const struct extent_buffer *eb, int nr)
 407 {
 408         unsigned long ptr;
 409
 410         ptr = offsetof(struct btrfs_node, ptrs) +
 411                 sizeof(struct btrfs_key_ptr) * nr;
 412         return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
 413 }
 414
 415 static inline void btrfs_set_node_ptr_generation(const struct extent_buffer *eb,
 416                                                  int nr, u64 val)
 417 {
 418         unsigned long ptr;
 419
 420         ptr = offsetof(struct btrfs_node, ptrs) +
 421                 sizeof(struct btrfs_key_ptr) * nr;
 422         btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
 423 }
 424
 425 static inline unsigned long btrfs_node_key_ptr_offset(const struct extent_buffer *eb, int nr)
 426 {
 427         return offsetof(struct btrfs_node, ptrs) +
 428                 sizeof(struct btrfs_key_ptr) * nr;
 429 }
 430
 431 void btrfs_node_key(const struct extent_buffer *eb,
 432                     struct btrfs_disk_key *disk_key, int nr);
 433
 434 static inline void btrfs_set_node_key(const struct extent_buffer *eb,
 435                                       struct btrfs_disk_key *disk_key, int nr)
 436 {
 437         unsigned long ptr;
 438
 439         ptr = btrfs_node_key_ptr_offset(eb, nr);
 440         write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
 441                         struct btrfs_key_ptr, key, disk_key);
 442 }
 443
 444 /* struct btrfs_item */
 445 BTRFS_SETGET_FUNCS(raw_item_offset, struct btrfs_item, offset, 32);
 446 BTRFS_SETGET_FUNCS(raw_item_size, struct btrfs_item, size, 32);
 447 BTRFS_SETGET_STACK_FUNCS(stack_item_offset, struct btrfs_item, offset, 32);
 448 BTRFS_SETGET_STACK_FUNCS(stack_item_size, struct btrfs_item, size, 32);
 449
 450 static inline unsigned long btrfs_item_nr_offset(const struct extent_buffer *eb, int nr)
 451 {
 452         return offsetof(struct btrfs_leaf, items) +
 453                 sizeof(struct btrfs_item) * nr;
 454 }
 455
 456 static inline struct btrfs_item *btrfs_item_nr(const struct extent_buffer *eb, int nr)
 457 {
 458         return (struct btrfs_item *)btrfs_item_nr_offset(eb, nr);
 459 }
 460
 461 #define BTRFS_ITEM_SETGET_FUNCS(member)                                         \
 462 static inline u32 btrfs_item_##member(const struct extent_buffer *eb, int slot) \
 463 {                                                                               \
 464         return btrfs_raw_item_##member(eb, btrfs_item_nr(eb, slot));            \
 465 }                                                                               \
 466 static inline void btrfs_set_item_##member(const struct extent_buffer *eb,      \
 467                                            int slot, u32 val)                   \
 468 {                                                                               \
 469         btrfs_set_raw_item_##member(eb, btrfs_item_nr(eb, slot), val);          \
 470 }                                                                               \
 471 static inline u32 btrfs_token_item_##member(struct btrfs_map_token *token,      \
 472                                             int slot)                           \
 473 {                                                                               \
 474         struct btrfs_item *item = btrfs_item_nr(token->eb, slot);               \
 475         return btrfs_token_raw_item_##member(token, item);                      \
 476 }                                                                               \
 477 static inline void btrfs_set_token_item_##member(struct btrfs_map_token *token, \
 478                                                  int slot, u32 val)             \
 479 {                                                                               \
 480         struct btrfs_item *item = btrfs_item_nr(token->eb, slot);               \
 481         btrfs_set_token_raw_item_##member(token, item, val);                    \
 482 }
 483
 484 BTRFS_ITEM_SETGET_FUNCS(offset)
 485 BTRFS_ITEM_SETGET_FUNCS(size);
 486
 487 static inline u32 btrfs_item_data_end(const struct extent_buffer *eb, int nr)
 488 {
 489         return btrfs_item_offset(eb, nr) + btrfs_item_size(eb, nr);
 490 }
 491
 492 static inline void btrfs_item_key(const struct extent_buffer *eb,
 493                            struct btrfs_disk_key *disk_key, int nr)
 494 {
 495         struct btrfs_item *item = btrfs_item_nr(eb, nr);
 496
 497         read_eb_member(eb, item, struct btrfs_item, key, disk_key);
 498 }
 499
 500 static inline void btrfs_set_item_key(struct extent_buffer *eb,
 501                                       struct btrfs_disk_key *disk_key, int nr)
 502 {
 503         struct btrfs_item *item = btrfs_item_nr(eb, nr);
 504
 505         write_eb_member(eb, item, struct btrfs_item, key, disk_key);
 506 }
 507
 508 BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);
 509
 510 /* struct btrfs_root_ref */
 511 BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
 512 BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
 513 BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);
 514 BTRFS_SETGET_STACK_FUNCS(stack_root_ref_dirid, struct btrfs_root_ref, dirid, 64);
 515 BTRFS_SETGET_STACK_FUNCS(stack_root_ref_sequence, struct btrfs_root_ref, sequence, 64);
 516 BTRFS_SETGET_STACK_FUNCS(stack_root_ref_name_len, struct btrfs_root_ref, name_len, 16);
 517
 518 /* struct btrfs_dir_item */
 519 BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
 520 BTRFS_SETGET_FUNCS(dir_flags, struct btrfs_dir_item, type, 8);
 521 BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
 522 BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
 523 BTRFS_SETGET_STACK_FUNCS(stack_dir_flags, struct btrfs_dir_item, type, 8);
 524 BTRFS_SETGET_STACK_FUNCS(stack_dir_data_len, struct btrfs_dir_item, data_len, 16);
 525 BTRFS_SETGET_STACK_FUNCS(stack_dir_name_len, struct btrfs_dir_item, name_len, 16);
 526 BTRFS_SETGET_STACK_FUNCS(stack_dir_transid, struct btrfs_dir_item, transid, 64);
 527
 528 static inline u8 btrfs_dir_ftype(const struct extent_buffer *eb,
 529                                  const struct btrfs_dir_item *item)
 530 {
 531         return btrfs_dir_flags_to_ftype(btrfs_dir_flags(eb, item));
 532 }
 533
 534 static inline u8 btrfs_stack_dir_ftype(const struct btrfs_dir_item *item)
 535 {
 536         return btrfs_dir_flags_to_ftype(btrfs_stack_dir_flags(item));
 537 }
 538
 539 static inline void btrfs_dir_item_key(const struct extent_buffer *eb,
 540                                       const struct btrfs_dir_item *item,
 541                                       struct btrfs_disk_key *key)
 542 {
 543         read_eb_member(eb, item, struct btrfs_dir_item, location, key);
 544 }
 545
 546 static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
 547                                           struct btrfs_dir_item *item,
 548                                           const struct btrfs_disk_key *key)
 549 {
 550         write_eb_member(eb, item, struct btrfs_dir_item, location, key);
 551 }
 552
 553 BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header,
 554                    num_entries, 64);
 555 BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header,
 556                    num_bitmaps, 64);
 557 BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header,
 558                    generation, 64);
 559
 560 static inline void btrfs_free_space_key(const struct extent_buffer *eb,
 561                                         const struct btrfs_free_space_header *h,
 562                                         struct btrfs_disk_key *key)
 563 {
 564         read_eb_member(eb, h, struct btrfs_free_space_header, location, key);
 565 }
 566
 567 static inline void btrfs_set_free_space_key(struct extent_buffer *eb,
 568                                             struct btrfs_free_space_header *h,
 569                                             const struct btrfs_disk_key *key)
 570 {
 571         write_eb_member(eb, h, struct btrfs_free_space_header, location, key);
 572 }
 573
 574 /* struct btrfs_disk_key */
 575 BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key, objectid, 64);
 576 BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
 577 BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
 578
 579 #ifdef __LITTLE_ENDIAN
 580
 581 /*
 582  * Optimized helpers for little-endian architectures where CPU and on-disk
 583  * structures have the same endianness and we can skip conversions.
 584  */
 585
 586 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu_key,
 587                                          const struct btrfs_disk_key *disk_key)
 588 {
 589         memcpy(cpu_key, disk_key, sizeof(struct btrfs_key));
 590 }
 591
 592 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk_key,
 593                                          const struct btrfs_key *cpu_key)
 594 {
 595         memcpy(disk_key, cpu_key, sizeof(struct btrfs_key));
 596 }
 597
 598 static inline void btrfs_node_key_to_cpu(const struct extent_buffer *eb,
 599                                          struct btrfs_key *cpu_key, int nr)
 600 {
 601         struct btrfs_disk_key *disk_key = (struct btrfs_disk_key *)cpu_key;
 602
 603         btrfs_node_key(eb, disk_key, nr);
 604 }
 605
 606 static inline void btrfs_item_key_to_cpu(const struct extent_buffer *eb,
 607                                          struct btrfs_key *cpu_key, int nr)
 608 {
 609         struct btrfs_disk_key *disk_key = (struct btrfs_disk_key *)cpu_key;
 610
 611         btrfs_item_key(eb, disk_key, nr);
 612 }
 613
 614 static inline void btrfs_dir_item_key_to_cpu(const struct extent_buffer *eb,
 615                                              const struct btrfs_dir_item *item,
 616                                              struct btrfs_key *cpu_key)
 617 {
 618         struct btrfs_disk_key *disk_key = (struct btrfs_disk_key *)cpu_key;
 619
 620         btrfs_dir_item_key(eb, item, disk_key);
 621 }
 622
 623 #else
 624
 625 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
 626                                          const struct btrfs_disk_key *disk)
 627 {
 628         cpu->offset = le64_to_cpu(disk->offset);
 629         cpu->type = disk->type;
 630         cpu->objectid = le64_to_cpu(disk->objectid);
 631 }
 632
 633 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
 634                                          const struct btrfs_key *cpu)
 635 {
 636         disk->offset = cpu_to_le64(cpu->offset);
 637         disk->type = cpu->type;
 638         disk->objectid = cpu_to_le64(cpu->objectid);
 639 }
 640
 641 static inline void btrfs_node_key_to_cpu(const struct extent_buffer *eb,
 642                                          struct btrfs_key *key, int nr)
 643 {
 644         struct btrfs_disk_key disk_key;
 645
 646         btrfs_node_key(eb, &disk_key, nr);
 647         btrfs_disk_key_to_cpu(key, &disk_key);
 648 }
 649
 650 static inline void btrfs_item_key_to_cpu(const struct extent_buffer *eb,
 651                                          struct btrfs_key *key, int nr)
 652 {
 653         struct btrfs_disk_key disk_key;
 654
 655         btrfs_item_key(eb, &disk_key, nr);
 656         btrfs_disk_key_to_cpu(key, &disk_key);
 657 }
 658
 659 static inline void btrfs_dir_item_key_to_cpu(const struct extent_buffer *eb,
 660                                              const struct btrfs_dir_item *item,
 661                                              struct btrfs_key *key)
 662 {
 663         struct btrfs_disk_key disk_key;
 664
 665         btrfs_dir_item_key(eb, item, &disk_key);
 666         btrfs_disk_key_to_cpu(key, &disk_key);
 667 }
 668
 669 #endif
 670
 671 /* struct btrfs_header */
 672 BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
 673 BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header, generation, 64);
 674 BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
 675 BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
 676 BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
 677 BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
 678 BTRFS_SETGET_STACK_FUNCS(stack_header_generation, struct btrfs_header,
 679                          generation, 64);
 680 BTRFS_SETGET_STACK_FUNCS(stack_header_owner, struct btrfs_header, owner, 64);
 681 BTRFS_SETGET_STACK_FUNCS(stack_header_nritems, struct btrfs_header, nritems, 32);
 682 BTRFS_SETGET_STACK_FUNCS(stack_header_bytenr, struct btrfs_header, bytenr, 64);
 683
 684 static inline int btrfs_header_flag(const struct extent_buffer *eb, u64 flag)
 685 {
 686         return (btrfs_header_flags(eb) & flag) == flag;
 687 }
 688
 689 static inline void btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
 690 {
 691         u64 flags = btrfs_header_flags(eb);
 692
 693         btrfs_set_header_flags(eb, flags | flag);
 694 }
 695
 696 static inline void btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
 697 {
 698         u64 flags = btrfs_header_flags(eb);
 699
 700         btrfs_set_header_flags(eb, flags & ~flag);
 701 }
 702
 703 static inline int btrfs_header_backref_rev(const struct extent_buffer *eb)
 704 {
 705         u64 flags = btrfs_header_flags(eb);
 706
 707         return flags >> BTRFS_BACKREF_REV_SHIFT;
 708 }
 709
 710 static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb, int rev)
 711 {
 712         u64 flags = btrfs_header_flags(eb);
 713
 714         flags &= ~BTRFS_BACKREF_REV_MASK;
 715         flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
 716         btrfs_set_header_flags(eb, flags);
 717 }
 718
 719 static inline int btrfs_is_leaf(const struct extent_buffer *eb)
 720 {
 721         return btrfs_header_level(eb) == 0;
 722 }
 723
 724 /* struct btrfs_root_item */
 725 BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item, generation, 64);
 726 BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
 727 BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
 728 BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
 729
 730 BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item, generation, 64);
 731 BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
 732 BTRFS_SETGET_STACK_FUNCS(root_drop_level, struct btrfs_root_item, drop_level, 8);
 733 BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
 734 BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
 735 BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
 736 BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
 737 BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
 738 BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
 739 BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
 740                          last_snapshot, 64);
 741 BTRFS_SETGET_STACK_FUNCS(root_generation_v2, struct btrfs_root_item,
 742                          generation_v2, 64);
 743 BTRFS_SETGET_STACK_FUNCS(root_ctransid, struct btrfs_root_item, ctransid, 64);
 744 BTRFS_SETGET_STACK_FUNCS(root_otransid, struct btrfs_root_item, otransid, 64);
 745 BTRFS_SETGET_STACK_FUNCS(root_stransid, struct btrfs_root_item, stransid, 64);
 746 BTRFS_SETGET_STACK_FUNCS(root_rtransid, struct btrfs_root_item, rtransid, 64);
 747
 748 /* struct btrfs_root_backup */
 749 BTRFS_SETGET_STACK_FUNCS(backup_tree_root, struct btrfs_root_backup,
 750                    tree_root, 64);
 751 BTRFS_SETGET_STACK_FUNCS(backup_tree_root_gen, struct btrfs_root_backup,
 752                    tree_root_gen, 64);
 753 BTRFS_SETGET_STACK_FUNCS(backup_tree_root_level, struct btrfs_root_backup,
 754                    tree_root_level, 8);
 755
 756 BTRFS_SETGET_STACK_FUNCS(backup_chunk_root, struct btrfs_root_backup,
 757                    chunk_root, 64);
 758 BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_gen, struct btrfs_root_backup,
 759                    chunk_root_gen, 64);
 760 BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_level, struct btrfs_root_backup,
 761                    chunk_root_level, 8);
 762
 763 BTRFS_SETGET_STACK_FUNCS(backup_extent_root, struct btrfs_root_backup,
 764                    extent_root, 64);
 765 BTRFS_SETGET_STACK_FUNCS(backup_extent_root_gen, struct btrfs_root_backup,
 766                    extent_root_gen, 64);
 767 BTRFS_SETGET_STACK_FUNCS(backup_extent_root_level, struct btrfs_root_backup,
 768                    extent_root_level, 8);
 769
 770 BTRFS_SETGET_STACK_FUNCS(backup_fs_root, struct btrfs_root_backup,
 771                    fs_root, 64);
 772 BTRFS_SETGET_STACK_FUNCS(backup_fs_root_gen, struct btrfs_root_backup,
 773                    fs_root_gen, 64);
 774 BTRFS_SETGET_STACK_FUNCS(backup_fs_root_level, struct btrfs_root_backup,
 775                    fs_root_level, 8);
 776
 777 BTRFS_SETGET_STACK_FUNCS(backup_dev_root, struct btrfs_root_backup,
 778                    dev_root, 64);
 779 BTRFS_SETGET_STACK_FUNCS(backup_dev_root_gen, struct btrfs_root_backup,
 780                    dev_root_gen, 64);
 781 BTRFS_SETGET_STACK_FUNCS(backup_dev_root_level, struct btrfs_root_backup,
 782                    dev_root_level, 8);
 783
 784 BTRFS_SETGET_STACK_FUNCS(backup_csum_root, struct btrfs_root_backup,
 785                    csum_root, 64);
 786 BTRFS_SETGET_STACK_FUNCS(backup_csum_root_gen, struct btrfs_root_backup,
 787                    csum_root_gen, 64);
 788 BTRFS_SETGET_STACK_FUNCS(backup_csum_root_level, struct btrfs_root_backup,
 789                    csum_root_level, 8);
 790 BTRFS_SETGET_STACK_FUNCS(backup_total_bytes, struct btrfs_root_backup,
 791                    total_bytes, 64);
 792 BTRFS_SETGET_STACK_FUNCS(backup_bytes_used, struct btrfs_root_backup,
 793                    bytes_used, 64);
 794 BTRFS_SETGET_STACK_FUNCS(backup_num_devices, struct btrfs_root_backup,
 795                    num_devices, 64);
 796
 797 /* struct btrfs_balance_item */
 798 BTRFS_SETGET_FUNCS(balance_flags, struct btrfs_balance_item, flags, 64);
 799
 800 static inline void btrfs_balance_data(const struct extent_buffer *eb,
 801                                       const struct btrfs_balance_item *bi,
 802                                       struct btrfs_disk_balance_args *ba)
 803 {
 804         read_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
 805 }
 806
 807 static inline void btrfs_set_balance_data(struct extent_buffer *eb,
 808                                           struct btrfs_balance_item *bi,
 809                                           const struct btrfs_disk_balance_args *ba)
 810 {
 811         write_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
 812 }
 813
 814 static inline void btrfs_balance_meta(const struct extent_buffer *eb,
 815                                       const struct btrfs_balance_item *bi,
 816                                       struct btrfs_disk_balance_args *ba)
 817 {
 818         read_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
 819 }
 820
 821 static inline void btrfs_set_balance_meta(struct extent_buffer *eb,
 822                                           struct btrfs_balance_item *bi,
 823                                           const struct btrfs_disk_balance_args *ba)
 824 {
 825         write_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
 826 }
 827
 828 static inline void btrfs_balance_sys(const struct extent_buffer *eb,
 829                                      const struct btrfs_balance_item *bi,
 830                                      struct btrfs_disk_balance_args *ba)
 831 {
 832         read_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
 833 }
 834
 835 static inline void btrfs_set_balance_sys(struct extent_buffer *eb,
 836                                          struct btrfs_balance_item *bi,
 837                                          const struct btrfs_disk_balance_args *ba)
 838 {
 839         write_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
 840 }
 841
 842 static inline void btrfs_disk_balance_args_to_cpu(struct btrfs_balance_args *cpu,
 843                                const struct btrfs_disk_balance_args *disk)
 844 {
 845         memset(cpu, 0, sizeof(*cpu));
 846
 847         cpu->profiles = le64_to_cpu(disk->profiles);
 848         cpu->usage = le64_to_cpu(disk->usage);
 849         cpu->devid = le64_to_cpu(disk->devid);
 850         cpu->pstart = le64_to_cpu(disk->pstart);
 851         cpu->pend = le64_to_cpu(disk->pend);
 852         cpu->vstart = le64_to_cpu(disk->vstart);
 853         cpu->vend = le64_to_cpu(disk->vend);
 854         cpu->target = le64_to_cpu(disk->target);
 855         cpu->flags = le64_to_cpu(disk->flags);
 856         cpu->limit = le64_to_cpu(disk->limit);
 857         cpu->stripes_min = le32_to_cpu(disk->stripes_min);
 858         cpu->stripes_max = le32_to_cpu(disk->stripes_max);
 859 }
 860
 861 static inline void btrfs_cpu_balance_args_to_disk(
 862                                 struct btrfs_disk_balance_args *disk,
 863                                 const struct btrfs_balance_args *cpu)
 864 {
 865         memset(disk, 0, sizeof(*disk));
 866
 867         disk->profiles = cpu_to_le64(cpu->profiles);
 868         disk->usage = cpu_to_le64(cpu->usage);
 869         disk->devid = cpu_to_le64(cpu->devid);
 870         disk->pstart = cpu_to_le64(cpu->pstart);
 871         disk->pend = cpu_to_le64(cpu->pend);
 872         disk->vstart = cpu_to_le64(cpu->vstart);
 873         disk->vend = cpu_to_le64(cpu->vend);
 874         disk->target = cpu_to_le64(cpu->target);
 875         disk->flags = cpu_to_le64(cpu->flags);
 876         disk->limit = cpu_to_le64(cpu->limit);
 877         disk->stripes_min = cpu_to_le32(cpu->stripes_min);
 878         disk->stripes_max = cpu_to_le32(cpu->stripes_max);
 879 }
 880
 881 /* struct btrfs_super_block */
 882 BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
 883 BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
 884 BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
 885                          generation, 64);
 886 BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
 887 BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
 888                          struct btrfs_super_block, sys_chunk_array_size, 32);
 889 BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
 890                          struct btrfs_super_block, chunk_root_generation, 64);
 891 BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
 892                          root_level, 8);
 893 BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
 894                          chunk_root, 64);
 895 BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
 896                          chunk_root_level, 8);
 897 BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block, log_root, 64);
 898 BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
 899                          log_root_level, 8);
 900 BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
 901                          total_bytes, 64);
 902 BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
 903                          bytes_used, 64);
 904 BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
 905                          sectorsize, 32);
 906 BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
 907                          nodesize, 32);
 908 BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
 909                          stripesize, 32);
 910 BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
 911                          root_dir_objectid, 64);
 912 BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
 913                          num_devices, 64);
 914 BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block,
 915                          compat_flags, 64);
 916 BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
 917                          compat_ro_flags, 64);
 918 BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
 919                          incompat_flags, 64);
 920 BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
 921                          csum_type, 16);
 922 BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,
 923                          cache_generation, 64);
 924 BTRFS_SETGET_STACK_FUNCS(super_magic, struct btrfs_super_block, magic, 64);
 925 BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block,
 926                          uuid_tree_generation, 64);
 927 BTRFS_SETGET_STACK_FUNCS(super_nr_global_roots, struct btrfs_super_block,
 928                          nr_global_roots, 64);
 929
 930 /* struct btrfs_file_extent_item */
 931 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item,
 932                          type, 8);
 933 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_bytenr,
 934                          struct btrfs_file_extent_item, disk_bytenr, 64);
 935 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_offset,
 936                          struct btrfs_file_extent_item, offset, 64);
 937 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_generation,
 938                          struct btrfs_file_extent_item, generation, 64);
 939 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_num_bytes,
 940                          struct btrfs_file_extent_item, num_bytes, 64);
 941 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_ram_bytes,
 942                          struct btrfs_file_extent_item, ram_bytes, 64);
 943 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_num_bytes,
 944                          struct btrfs_file_extent_item, disk_num_bytes, 64);
 945 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_compression,
 946                          struct btrfs_file_extent_item, compression, 8);
 947
 948
 949 BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
 950 BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
 951                    disk_bytenr, 64);
 952 BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
 953                    generation, 64);
 954 BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
 955                    disk_num_bytes, 64);
 956 BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
 957                   offset, 64);
 958 BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
 959                    num_bytes, 64);
 960 BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
 961                    ram_bytes, 64);
 962 BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
 963                    compression, 8);
 964 BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
 965                    encryption, 8);
 966 BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
 967                    other_encoding, 16);
 968
 969 /* btrfs_qgroup_status_item */
 970 BTRFS_SETGET_FUNCS(qgroup_status_generation, struct btrfs_qgroup_status_item,
 971                    generation, 64);
 972 BTRFS_SETGET_FUNCS(qgroup_status_version, struct btrfs_qgroup_status_item,
 973                    version, 64);
 974 BTRFS_SETGET_FUNCS(qgroup_status_flags, struct btrfs_qgroup_status_item,
 975                    flags, 64);
 976 BTRFS_SETGET_FUNCS(qgroup_status_rescan, struct btrfs_qgroup_status_item,
 977                    rescan, 64);
 978
 979 /* btrfs_qgroup_info_item */
 980 BTRFS_SETGET_FUNCS(qgroup_info_generation, struct btrfs_qgroup_info_item,
 981                    generation, 64);
 982 BTRFS_SETGET_FUNCS(qgroup_info_rfer, struct btrfs_qgroup_info_item, rfer, 64);
 983 BTRFS_SETGET_FUNCS(qgroup_info_rfer_cmpr, struct btrfs_qgroup_info_item,
 984                    rfer_cmpr, 64);
 985 BTRFS_SETGET_FUNCS(qgroup_info_excl, struct btrfs_qgroup_info_item, excl, 64);
 986 BTRFS_SETGET_FUNCS(qgroup_info_excl_cmpr, struct btrfs_qgroup_info_item,
 987                    excl_cmpr, 64);
 988
 989 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_generation,
 990                          struct btrfs_qgroup_info_item, generation, 64);
 991 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer, struct btrfs_qgroup_info_item,
 992                          rfer, 64);
 993 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer_cmpr,
 994                          struct btrfs_qgroup_info_item, rfer_cmpr, 64);
 995 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl, struct btrfs_qgroup_info_item,
 996                          excl, 64);
 997 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl_cmpr,
 998                          struct btrfs_qgroup_info_item, excl_cmpr, 64);
 999
1000 /* btrfs_qgroup_limit_item */
1001 BTRFS_SETGET_FUNCS(qgroup_limit_flags, struct btrfs_qgroup_limit_item, flags, 64);
1002 BTRFS_SETGET_FUNCS(qgroup_limit_max_rfer, struct btrfs_qgroup_limit_item,
1003                    max_rfer, 64);
1004 BTRFS_SETGET_FUNCS(qgroup_limit_max_excl, struct btrfs_qgroup_limit_item,
1005                    max_excl, 64);
1006 BTRFS_SETGET_FUNCS(qgroup_limit_rsv_rfer, struct btrfs_qgroup_limit_item,
1007                    rsv_rfer, 64);
1008 BTRFS_SETGET_FUNCS(qgroup_limit_rsv_excl, struct btrfs_qgroup_limit_item,
1009                    rsv_excl, 64);
1010 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_flags,
1011                          struct btrfs_qgroup_limit_item, flags, 64);
1012 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_max_rfer,
1013                          struct btrfs_qgroup_limit_item, max_rfer, 64);
1014 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_max_excl,
1015                          struct btrfs_qgroup_limit_item, max_excl, 64);
1016 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_rsv_rfer,
1017                          struct btrfs_qgroup_limit_item, rsv_rfer, 64);
1018 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_limit_rsv_excl,
1019                          struct btrfs_qgroup_limit_item, rsv_excl, 64);
1020
1021 /* btrfs_dev_replace_item */
1022 BTRFS_SETGET_FUNCS(dev_replace_src_devid,
1023                    struct btrfs_dev_replace_item, src_devid, 64);
1024 BTRFS_SETGET_FUNCS(dev_replace_cont_reading_from_srcdev_mode,
1025                    struct btrfs_dev_replace_item, cont_reading_from_srcdev_mode,
1026                    64);
1027 BTRFS_SETGET_FUNCS(dev_replace_replace_state, struct btrfs_dev_replace_item,
1028                    replace_state, 64);
1029 BTRFS_SETGET_FUNCS(dev_replace_time_started, struct btrfs_dev_replace_item,
1030                    time_started, 64);
1031 BTRFS_SETGET_FUNCS(dev_replace_time_stopped, struct btrfs_dev_replace_item,
1032                    time_stopped, 64);
1033 BTRFS_SETGET_FUNCS(dev_replace_num_write_errors, struct btrfs_dev_replace_item,
1034                    num_write_errors, 64);
1035 BTRFS_SETGET_FUNCS(dev_replace_num_uncorrectable_read_errors,
1036                    struct btrfs_dev_replace_item, num_uncorrectable_read_errors,
1037                    64);
1038 BTRFS_SETGET_FUNCS(dev_replace_cursor_left, struct btrfs_dev_replace_item,
1039                    cursor_left, 64);
1040 BTRFS_SETGET_FUNCS(dev_replace_cursor_right, struct btrfs_dev_replace_item,
1041                    cursor_right, 64);
1042
1043 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_src_devid,
1044                          struct btrfs_dev_replace_item, src_devid, 64);
1045 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cont_reading_from_srcdev_mode,
1046                          struct btrfs_dev_replace_item,
1047                          cont_reading_from_srcdev_mode, 64);
1048 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_replace_state,
1049                          struct btrfs_dev_replace_item, replace_state, 64);
1050 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_started,
1051                          struct btrfs_dev_replace_item, time_started, 64);
1052 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_stopped,
1053                          struct btrfs_dev_replace_item, time_stopped, 64);
1054 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_write_errors,
1055                          struct btrfs_dev_replace_item, num_write_errors, 64);
1056 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_uncorrectable_read_errors,
1057                          struct btrfs_dev_replace_item,
1058                          num_uncorrectable_read_errors, 64);
1059 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_left,
1060                          struct btrfs_dev_replace_item, cursor_left, 64);
1061 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_right,
1062                          struct btrfs_dev_replace_item, cursor_right, 64);
1063
1064 /* btrfs_verity_descriptor_item */
1065 BTRFS_SETGET_FUNCS(verity_descriptor_encryption, struct btrfs_verity_descriptor_item,
1066                    encryption, 8);
1067 BTRFS_SETGET_FUNCS(verity_descriptor_size, struct btrfs_verity_descriptor_item,
1068                    size, 64);
1069 BTRFS_SETGET_STACK_FUNCS(stack_verity_descriptor_encryption,
1070                          struct btrfs_verity_descriptor_item, encryption, 8);
1071 BTRFS_SETGET_STACK_FUNCS(stack_verity_descriptor_size,
1072                          struct btrfs_verity_descriptor_item, size, 64);
1073
1074 /* Cast into the data area of the leaf. */
1075 #define btrfs_item_ptr(leaf, slot, type)                                \
1076         ((type *)(btrfs_item_nr_offset(leaf, 0) + btrfs_item_offset(leaf, slot)))
1077
1078 #define btrfs_item_ptr_offset(leaf, slot)                               \
1079         ((unsigned long)(btrfs_item_nr_offset(leaf, 0) + btrfs_item_offset(leaf, slot)))
1080
1081 #endif