Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
       2                 :            : /*
       3                 :            :    md_p.h : physical layout of Linux RAID devices
       4                 :            :           Copyright (C) 1996-98 Ingo Molnar, Gadi Oxman
       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 as published by
       8                 :            :    the Free Software Foundation; either version 2, or (at your option)
       9                 :            :    any later version.
      10                 :            :    
      11                 :            :    You should have received a copy of the GNU General Public License
      12                 :            :    (for example /usr/src/linux/COPYING); if not, write to the Free
      13                 :            :    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
      14                 :            : */
      15                 :            : 
      16                 :            : #ifndef _MD_P_H
      17                 :            : #define _MD_P_H
      18                 :            : 
      19                 :            : #include <linux/types.h>
      20                 :            : #include <asm/byteorder.h>
      21                 :            : 
      22                 :            : /*
      23                 :            :  * RAID superblock.
      24                 :            :  *
      25                 :            :  * The RAID superblock maintains some statistics on each RAID configuration.
      26                 :            :  * Each real device in the RAID set contains it near the end of the device.
      27                 :            :  * Some of the ideas are copied from the ext2fs implementation.
      28                 :            :  *
      29                 :            :  * We currently use 4096 bytes as follows:
      30                 :            :  *
      31                 :            :  *      word offset     function
      32                 :            :  *
      33                 :            :  *         0  -    31   Constant generic RAID device information.
      34                 :            :  *        32  -    63   Generic state information.
      35                 :            :  *        64  -   127   Personality specific information.
      36                 :            :  *       128  -   511   12 32-words descriptors of the disks in the raid set.
      37                 :            :  *       512  -   911   Reserved.
      38                 :            :  *       912  -  1023   Disk specific descriptor.
      39                 :            :  */
      40                 :            : 
      41                 :            : /*
      42                 :            :  * If x is the real device size in bytes, we return an apparent size of:
      43                 :            :  *
      44                 :            :  *      y = (x & ~(MD_RESERVED_BYTES - 1)) - MD_RESERVED_BYTES
      45                 :            :  *
      46                 :            :  * and place the 4kB superblock at offset y.
      47                 :            :  */
      48                 :            : #define MD_RESERVED_BYTES               (64 * 1024)
      49                 :            : #define MD_RESERVED_SECTORS             (MD_RESERVED_BYTES / 512)
      50                 :            : 
      51                 :            : #define MD_NEW_SIZE_SECTORS(x)          ((x & ~(MD_RESERVED_SECTORS - 1)) - MD_RESERVED_SECTORS)
      52                 :            : 
      53                 :            : #define MD_SB_BYTES                     4096
      54                 :            : #define MD_SB_WORDS                     (MD_SB_BYTES / 4)
      55                 :            : #define MD_SB_SECTORS                   (MD_SB_BYTES / 512)
      56                 :            : 
      57                 :            : /*
      58                 :            :  * The following are counted in 32-bit words
      59                 :            :  */
      60                 :            : #define MD_SB_GENERIC_OFFSET            0
      61                 :            : #define MD_SB_PERSONALITY_OFFSET        64
      62                 :            : #define MD_SB_DISKS_OFFSET              128
      63                 :            : #define MD_SB_DESCRIPTOR_OFFSET         992
      64                 :            : 
      65                 :            : #define MD_SB_GENERIC_CONSTANT_WORDS    32
      66                 :            : #define MD_SB_GENERIC_STATE_WORDS       32
      67                 :            : #define MD_SB_GENERIC_WORDS             (MD_SB_GENERIC_CONSTANT_WORDS + MD_SB_GENERIC_STATE_WORDS)
      68                 :            : #define MD_SB_PERSONALITY_WORDS         64
      69                 :            : #define MD_SB_DESCRIPTOR_WORDS          32
      70                 :            : #define MD_SB_DISKS                     27
      71                 :            : #define MD_SB_DISKS_WORDS               (MD_SB_DISKS*MD_SB_DESCRIPTOR_WORDS)
      72                 :            : #define MD_SB_RESERVED_WORDS            (1024 - MD_SB_GENERIC_WORDS - MD_SB_PERSONALITY_WORDS - MD_SB_DISKS_WORDS - MD_SB_DESCRIPTOR_WORDS)
      73                 :            : #define MD_SB_EQUAL_WORDS               (MD_SB_GENERIC_WORDS + MD_SB_PERSONALITY_WORDS + MD_SB_DISKS_WORDS)
      74                 :            : 
      75                 :            : /*
      76                 :            :  * Device "operational" state bits
      77                 :            :  */
      78                 :            : #define MD_DISK_FAULTY          0 /* disk is faulty / operational */
      79                 :            : #define MD_DISK_ACTIVE          1 /* disk is running or spare disk */
      80                 :            : #define MD_DISK_SYNC            2 /* disk is in sync with the raid set */
      81                 :            : #define MD_DISK_REMOVED         3 /* disk is in sync with the raid set */
      82                 :            : #define MD_DISK_CLUSTER_ADD     4 /* Initiate a disk add across the cluster
      83                 :            :                                    * For clustered enviroments only.
      84                 :            :                                    */
      85                 :            : #define MD_DISK_CANDIDATE       5 /* disk is added as spare (local) until confirmed
      86                 :            :                                    * For clustered enviroments only.
      87                 :            :                                    */
      88                 :            : #define MD_DISK_FAILFAST        10 /* Send REQ_FAILFAST if there are multiple
      89                 :            :                                     * devices available - and don't try to
      90                 :            :                                     * correct read errors.
      91                 :            :                                     */
      92                 :            : 
      93                 :            : #define MD_DISK_WRITEMOSTLY     9 /* disk is "write-mostly" is RAID1 config.
      94                 :            :                                    * read requests will only be sent here in
      95                 :            :                                    * dire need
      96                 :            :                                    */
      97                 :            : #define MD_DISK_JOURNAL         18 /* disk is used as the write journal in RAID-5/6 */
      98                 :            : 
      99                 :            : #define MD_DISK_ROLE_SPARE      0xffff
     100                 :            : #define MD_DISK_ROLE_FAULTY     0xfffe
     101                 :            : #define MD_DISK_ROLE_JOURNAL    0xfffd
     102                 :            : #define MD_DISK_ROLE_MAX        0xff00 /* max value of regular disk role */
     103                 :            : 
     104                 :            : typedef struct mdp_device_descriptor_s {
     105                 :            :         __u32 number;           /* 0 Device number in the entire set          */
     106                 :            :         __u32 major;            /* 1 Device major number                      */
     107                 :            :         __u32 minor;            /* 2 Device minor number                      */
     108                 :            :         __u32 raid_disk;        /* 3 The role of the device in the raid set   */
     109                 :            :         __u32 state;            /* 4 Operational state                        */
     110                 :            :         __u32 reserved[MD_SB_DESCRIPTOR_WORDS - 5];
     111                 :            : } mdp_disk_t;
     112                 :            : 
     113                 :            : #define MD_SB_MAGIC             0xa92b4efc
     114                 :            : 
     115                 :            : /*
     116                 :            :  * Superblock state bits
     117                 :            :  */
     118                 :            : #define MD_SB_CLEAN             0
     119                 :            : #define MD_SB_ERRORS            1
     120                 :            : 
     121                 :            : #define MD_SB_CLUSTERED         5 /* MD is clustered */
     122                 :            : #define MD_SB_BITMAP_PRESENT    8 /* bitmap may be present nearby */
     123                 :            : 
     124                 :            : /*
     125                 :            :  * Notes:
     126                 :            :  * - if an array is being reshaped (restriped) in order to change the
     127                 :            :  *   the number of active devices in the array, 'raid_disks' will be
     128                 :            :  *   the larger of the old and new numbers.  'delta_disks' will
     129                 :            :  *   be the "new - old".  So if +ve, raid_disks is the new value, and
     130                 :            :  *   "raid_disks-delta_disks" is the old.  If -ve, raid_disks is the
     131                 :            :  *   old value and "raid_disks+delta_disks" is the new (smaller) value.
     132                 :            :  */
     133                 :            : 
     134                 :            : 
     135                 :            : typedef struct mdp_superblock_s {
     136                 :            :         /*
     137                 :            :          * Constant generic information
     138                 :            :          */
     139                 :            :         __u32 md_magic;         /*  0 MD identifier                           */
     140                 :            :         __u32 major_version;    /*  1 major version to which the set conforms */
     141                 :            :         __u32 minor_version;    /*  2 minor version ...                       */
     142                 :            :         __u32 patch_version;    /*  3 patchlevel version ...                  */
     143                 :            :         __u32 gvalid_words;     /*  4 Number of used words in this section    */
     144                 :            :         __u32 set_uuid0;        /*  5 Raid set identifier                     */
     145                 :            :         __u32 ctime;            /*  6 Creation time                           */
     146                 :            :         __u32 level;            /*  7 Raid personality                        */
     147                 :            :         __u32 size;             /*  8 Apparent size of each individual disk   */
     148                 :            :         __u32 nr_disks;         /*  9 total disks in the raid set             */
     149                 :            :         __u32 raid_disks;       /* 10 disks in a fully functional raid set    */
     150                 :            :         __u32 md_minor;         /* 11 preferred MD minor device number        */
     151                 :            :         __u32 not_persistent;   /* 12 does it have a persistent superblock    */
     152                 :            :         __u32 set_uuid1;        /* 13 Raid set identifier #2                  */
     153                 :            :         __u32 set_uuid2;        /* 14 Raid set identifier #3                  */
     154                 :            :         __u32 set_uuid3;        /* 15 Raid set identifier #4                  */
     155                 :            :         __u32 gstate_creserved[MD_SB_GENERIC_CONSTANT_WORDS - 16];
     156                 :            : 
     157                 :            :         /*
     158                 :            :          * Generic state information
     159                 :            :          */
     160                 :            :         __u32 utime;            /*  0 Superblock update time                  */
     161                 :            :         __u32 state;            /*  1 State bits (clean, ...)                 */
     162                 :            :         __u32 active_disks;     /*  2 Number of currently active disks        */
     163                 :            :         __u32 working_disks;    /*  3 Number of working disks                 */
     164                 :            :         __u32 failed_disks;     /*  4 Number of failed disks                  */
     165                 :            :         __u32 spare_disks;      /*  5 Number of spare disks                   */
     166                 :            :         __u32 sb_csum;          /*  6 checksum of the whole superblock        */
     167                 :            : #if defined(__BYTE_ORDER) ? __BYTE_ORDER == __BIG_ENDIAN : defined(__BIG_ENDIAN)
     168                 :            :         __u32 events_hi;        /*  7 high-order of superblock update count   */
     169                 :            :         __u32 events_lo;        /*  8 low-order of superblock update count    */
     170                 :            :         __u32 cp_events_hi;     /*  9 high-order of checkpoint update count   */
     171                 :            :         __u32 cp_events_lo;     /* 10 low-order of checkpoint update count    */
     172                 :            : #elif defined(__BYTE_ORDER) ? __BYTE_ORDER == __LITTLE_ENDIAN : defined(__LITTLE_ENDIAN)
     173                 :            :         __u32 events_lo;        /*  7 low-order of superblock update count    */
     174                 :            :         __u32 events_hi;        /*  8 high-order of superblock update count   */
     175                 :            :         __u32 cp_events_lo;     /*  9 low-order of checkpoint update count    */
     176                 :            :         __u32 cp_events_hi;     /* 10 high-order of checkpoint update count   */
     177                 :            : #else
     178                 :            : #error unspecified endianness
     179                 :            : #endif
     180                 :            :         __u32 recovery_cp;      /* 11 recovery checkpoint sector count        */
     181                 :            :         /* There are only valid for minor_version > 90 */
     182                 :            :         __u64 reshape_position; /* 12,13 next address in array-space for reshape */
     183                 :            :         __u32 new_level;        /* 14 new level we are reshaping to           */
     184                 :            :         __u32 delta_disks;      /* 15 change in number of raid_disks          */
     185                 :            :         __u32 new_layout;       /* 16 new layout                              */
     186                 :            :         __u32 new_chunk;        /* 17 new chunk size (bytes)                  */
     187                 :            :         __u32 gstate_sreserved[MD_SB_GENERIC_STATE_WORDS - 18];
     188                 :            : 
     189                 :            :         /*
     190                 :            :          * Personality information
     191                 :            :          */
     192                 :            :         __u32 layout;           /*  0 the array's physical layout             */
     193                 :            :         __u32 chunk_size;       /*  1 chunk size in bytes                     */
     194                 :            :         __u32 root_pv;          /*  2 LV root PV */
     195                 :            :         __u32 root_block;       /*  3 LV root block */
     196                 :            :         __u32 pstate_reserved[MD_SB_PERSONALITY_WORDS - 4];
     197                 :            : 
     198                 :            :         /*
     199                 :            :          * Disks information
     200                 :            :          */
     201                 :            :         mdp_disk_t disks[MD_SB_DISKS];
     202                 :            : 
     203                 :            :         /*
     204                 :            :          * Reserved
     205                 :            :          */
     206                 :            :         __u32 reserved[MD_SB_RESERVED_WORDS];
     207                 :            : 
     208                 :            :         /*
     209                 :            :          * Active descriptor
     210                 :            :          */
     211                 :            :         mdp_disk_t this_disk;
     212                 :            : 
     213                 :            : } mdp_super_t;
     214                 :            : 
     215                 :          0 : static inline __u64 md_event(mdp_super_t *sb) {
     216                 :          0 :         __u64 ev = sb->events_hi;
     217         [ #  # ]:          0 :         return (ev<<32)| sb->events_lo;
     218                 :            : }
     219                 :            : 
     220                 :            : #define MD_SUPERBLOCK_1_TIME_SEC_MASK ((1ULL<<40) - 1)
     221                 :            : 
     222                 :            : /*
     223                 :            :  * The version-1 superblock :
     224                 :            :  * All numeric fields are little-endian.
     225                 :            :  *
     226                 :            :  * total size: 256 bytes plus 2 per device.
     227                 :            :  *  1K allows 384 devices.
     228                 :            :  */
     229                 :            : struct mdp_superblock_1 {
     230                 :            :         /* constant array information - 128 bytes */
     231                 :            :         __le32  magic;          /* MD_SB_MAGIC: 0xa92b4efc - little endian */
     232                 :            :         __le32  major_version;  /* 1 */
     233                 :            :         __le32  feature_map;    /* bit 0 set if 'bitmap_offset' is meaningful */
     234                 :            :         __le32  pad0;           /* always set to 0 when writing */
     235                 :            : 
     236                 :            :         __u8    set_uuid[16];   /* user-space generated. */
     237                 :            :         char    set_name[32];   /* set and interpreted by user-space */
     238                 :            : 
     239                 :            :         __le64  ctime;          /* lo 40 bits are seconds, top 24 are microseconds or 0*/
     240                 :            :         __le32  level;          /* -4 (multipath), -1 (linear), 0,1,4,5 */
     241                 :            :         __le32  layout;         /* only for raid5 and raid10 currently */
     242                 :            :         __le64  size;           /* used size of component devices, in 512byte sectors */
     243                 :            : 
     244                 :            :         __le32  chunksize;      /* in 512byte sectors */
     245                 :            :         __le32  raid_disks;
     246                 :            :         union {
     247                 :            :                 __le32  bitmap_offset;  /* sectors after start of superblock that bitmap starts
     248                 :            :                                          * NOTE: signed, so bitmap can be before superblock
     249                 :            :                                          * only meaningful of feature_map[0] is set.
     250                 :            :                                          */
     251                 :            : 
     252                 :            :                 /* only meaningful when feature_map[MD_FEATURE_PPL] is set */
     253                 :            :                 struct {
     254                 :            :                         __le16 offset; /* sectors from start of superblock that ppl starts (signed) */
     255                 :            :                         __le16 size; /* ppl size in sectors */
     256                 :            :                 } ppl;
     257                 :            :         };
     258                 :            : 
     259                 :            :         /* These are only valid with feature bit '4' */
     260                 :            :         __le32  new_level;      /* new level we are reshaping to                */
     261                 :            :         __le64  reshape_position;       /* next address in array-space for reshape */
     262                 :            :         __le32  delta_disks;    /* change in number of raid_disks               */
     263                 :            :         __le32  new_layout;     /* new layout                                   */
     264                 :            :         __le32  new_chunk;      /* new chunk size (512byte sectors)             */
     265                 :            :         __le32  new_offset;     /* signed number to add to data_offset in new
     266                 :            :                                  * layout.  0 == no-change.  This can be
     267                 :            :                                  * different on each device in the array.
     268                 :            :                                  */
     269                 :            : 
     270                 :            :         /* constant this-device information - 64 bytes */
     271                 :            :         __le64  data_offset;    /* sector start of data, often 0 */
     272                 :            :         __le64  data_size;      /* sectors in this device that can be used for data */
     273                 :            :         __le64  super_offset;   /* sector start of this superblock */
     274                 :            :         union {
     275                 :            :                 __le64  recovery_offset;/* sectors before this offset (from data_offset) have been recovered */
     276                 :            :                 __le64  journal_tail;/* journal tail of journal device (from data_offset) */
     277                 :            :         };
     278                 :            :         __le32  dev_number;     /* permanent identifier of this  device - not role in raid */
     279                 :            :         __le32  cnt_corrected_read; /* number of read errors that were corrected by re-writing */
     280                 :            :         __u8    device_uuid[16]; /* user-space setable, ignored by kernel */
     281                 :            :         __u8    devflags;       /* per-device flags.  Only two defined...*/
     282                 :            : #define WriteMostly1    1       /* mask for writemostly flag in above */
     283                 :            : #define FailFast1       2       /* Should avoid retries and fixups and just fail */
     284                 :            :         /* Bad block log.  If there are any bad blocks the feature flag is set.
     285                 :            :          * If offset and size are non-zero, that space is reserved and available
     286                 :            :          */
     287                 :            :         __u8    bblog_shift;    /* shift from sectors to block size */
     288                 :            :         __le16  bblog_size;     /* number of sectors reserved for list */
     289                 :            :         __le32  bblog_offset;   /* sector offset from superblock to bblog,
     290                 :            :                                  * signed - not unsigned */
     291                 :            : 
     292                 :            :         /* array state information - 64 bytes */
     293                 :            :         __le64  utime;          /* 40 bits second, 24 bits microseconds */
     294                 :            :         __le64  events;         /* incremented when superblock updated */
     295                 :            :         __le64  resync_offset;  /* data before this offset (from data_offset) known to be in sync */
     296                 :            :         __le32  sb_csum;        /* checksum up to devs[max_dev] */
     297                 :            :         __le32  max_dev;        /* size of devs[] array to consider */
     298                 :            :         __u8    pad3[64-32];    /* set to 0 when writing */
     299                 :            : 
     300                 :            :         /* device state information. Indexed by dev_number.
     301                 :            :          * 2 bytes per device
     302                 :            :          * Note there are no per-device state flags. State information is rolled
     303                 :            :          * into the 'roles' value.  If a device is spare or faulty, then it doesn't
     304                 :            :          * have a meaningful role.
     305                 :            :          */
     306                 :            :         __le16  dev_roles[0];   /* role in array, or 0xffff for a spare, or 0xfffe for faulty */
     307                 :            : };
     308                 :            : 
     309                 :            : /* feature_map bits */
     310                 :            : #define MD_FEATURE_BITMAP_OFFSET        1
     311                 :            : #define MD_FEATURE_RECOVERY_OFFSET      2 /* recovery_offset is present and
     312                 :            :                                            * must be honoured
     313                 :            :                                            */
     314                 :            : #define MD_FEATURE_RESHAPE_ACTIVE       4
     315                 :            : #define MD_FEATURE_BAD_BLOCKS           8 /* badblock list is not empty */
     316                 :            : #define MD_FEATURE_REPLACEMENT          16 /* This device is replacing an
     317                 :            :                                             * active device with same 'role'.
     318                 :            :                                             * 'recovery_offset' is also set.
     319                 :            :                                             */
     320                 :            : #define MD_FEATURE_RESHAPE_BACKWARDS    32 /* Reshape doesn't change number
     321                 :            :                                             * of devices, but is going
     322                 :            :                                             * backwards anyway.
     323                 :            :                                             */
     324                 :            : #define MD_FEATURE_NEW_OFFSET           64 /* new_offset must be honoured */
     325                 :            : #define MD_FEATURE_RECOVERY_BITMAP      128 /* recovery that is happening
     326                 :            :                                              * is guided by bitmap.
     327                 :            :                                              */
     328                 :            : #define MD_FEATURE_CLUSTERED            256 /* clustered MD */
     329                 :            : #define MD_FEATURE_JOURNAL              512 /* support write cache */
     330                 :            : #define MD_FEATURE_PPL                  1024 /* support PPL */
     331                 :            : #define MD_FEATURE_MULTIPLE_PPLS        2048 /* support for multiple PPLs */
     332                 :            : #define MD_FEATURE_RAID0_LAYOUT         4096 /* layout is meaningful for RAID0 */
     333                 :            : #define MD_FEATURE_ALL                  (MD_FEATURE_BITMAP_OFFSET       \
     334                 :            :                                         |MD_FEATURE_RECOVERY_OFFSET     \
     335                 :            :                                         |MD_FEATURE_RESHAPE_ACTIVE      \
     336                 :            :                                         |MD_FEATURE_BAD_BLOCKS          \
     337                 :            :                                         |MD_FEATURE_REPLACEMENT         \
     338                 :            :                                         |MD_FEATURE_RESHAPE_BACKWARDS   \
     339                 :            :                                         |MD_FEATURE_NEW_OFFSET          \
     340                 :            :                                         |MD_FEATURE_RECOVERY_BITMAP     \
     341                 :            :                                         |MD_FEATURE_CLUSTERED           \
     342                 :            :                                         |MD_FEATURE_JOURNAL             \
     343                 :            :                                         |MD_FEATURE_PPL                 \
     344                 :            :                                         |MD_FEATURE_MULTIPLE_PPLS       \
     345                 :            :                                         |MD_FEATURE_RAID0_LAYOUT        \
     346                 :            :                                         )
     347                 :            : 
     348                 :            : struct r5l_payload_header {
     349                 :            :         __le16 type;
     350                 :            :         __le16 flags;
     351                 :            : } __attribute__ ((__packed__));
     352                 :            : 
     353                 :            : enum r5l_payload_type {
     354                 :            :         R5LOG_PAYLOAD_DATA = 0,
     355                 :            :         R5LOG_PAYLOAD_PARITY = 1,
     356                 :            :         R5LOG_PAYLOAD_FLUSH = 2,
     357                 :            : };
     358                 :            : 
     359                 :            : struct r5l_payload_data_parity {
     360                 :            :         struct r5l_payload_header header;
     361                 :            :         __le32 size;            /* sector. data/parity size. each 4k
     362                 :            :                                  * has a checksum */
     363                 :            :         __le64 location;        /* sector. For data, it's raid sector. For
     364                 :            :                                  * parity, it's stripe sector */
     365                 :            :         __le32 checksum[];
     366                 :            : } __attribute__ ((__packed__));
     367                 :            : 
     368                 :            : enum r5l_payload_data_parity_flag {
     369                 :            :         R5LOG_PAYLOAD_FLAG_DISCARD = 1, /* payload is discard */
     370                 :            :         /*
     371                 :            :          * RESHAPED/RESHAPING is only set when there is reshape activity. Note,
     372                 :            :          * both data/parity of a stripe should have the same flag set
     373                 :            :          *
     374                 :            :          * RESHAPED: reshape is running, and this stripe finished reshape
     375                 :            :          * RESHAPING: reshape is running, and this stripe isn't reshaped
     376                 :            :          */
     377                 :            :         R5LOG_PAYLOAD_FLAG_RESHAPED = 2,
     378                 :            :         R5LOG_PAYLOAD_FLAG_RESHAPING = 3,
     379                 :            : };
     380                 :            : 
     381                 :            : struct r5l_payload_flush {
     382                 :            :         struct r5l_payload_header header;
     383                 :            :         __le32 size; /* flush_stripes size, bytes */
     384                 :            :         __le64 flush_stripes[];
     385                 :            : } __attribute__ ((__packed__));
     386                 :            : 
     387                 :            : enum r5l_payload_flush_flag {
     388                 :            :         R5LOG_PAYLOAD_FLAG_FLUSH_STRIPE = 1, /* data represents whole stripe */
     389                 :            : };
     390                 :            : 
     391                 :            : struct r5l_meta_block {
     392                 :            :         __le32 magic;
     393                 :            :         __le32 checksum;
     394                 :            :         __u8 version;
     395                 :            :         __u8 __zero_pading_1;
     396                 :            :         __le16 __zero_pading_2;
     397                 :            :         __le32 meta_size; /* whole size of the block */
     398                 :            : 
     399                 :            :         __le64 seq;
     400                 :            :         __le64 position; /* sector, start from rdev->data_offset, current position */
     401                 :            :         struct r5l_payload_header payloads[];
     402                 :            : } __attribute__ ((__packed__));
     403                 :            : 
     404                 :            : #define R5LOG_VERSION 0x1
     405                 :            : #define R5LOG_MAGIC 0x6433c509
     406                 :            : 
     407                 :            : struct ppl_header_entry {
     408                 :            :         __le64 data_sector;     /* raid sector of the new data */
     409                 :            :         __le32 pp_size;         /* length of partial parity */
     410                 :            :         __le32 data_size;       /* length of data */
     411                 :            :         __le32 parity_disk;     /* member disk containing parity */
     412                 :            :         __le32 checksum;        /* checksum of partial parity data for this
     413                 :            :                                  * entry (~crc32c) */
     414                 :            : } __attribute__ ((__packed__));
     415                 :            : 
     416                 :            : #define PPL_HEADER_SIZE 4096
     417                 :            : #define PPL_HDR_RESERVED 512
     418                 :            : #define PPL_HDR_ENTRY_SPACE \
     419                 :            :         (PPL_HEADER_SIZE - PPL_HDR_RESERVED - 4 * sizeof(__le32) - sizeof(__le64))
     420                 :            : #define PPL_HDR_MAX_ENTRIES \
     421                 :            :         (PPL_HDR_ENTRY_SPACE / sizeof(struct ppl_header_entry))
     422                 :            : 
     423                 :            : struct ppl_header {
     424                 :            :         __u8 reserved[PPL_HDR_RESERVED];/* reserved space, fill with 0xff */
     425                 :            :         __le32 signature;               /* signature (family number of volume) */
     426                 :            :         __le32 padding;                 /* zero pad */
     427                 :            :         __le64 generation;              /* generation number of the header */
     428                 :            :         __le32 entries_count;           /* number of entries in entry array */
     429                 :            :         __le32 checksum;                /* checksum of the header (~crc32c) */
     430                 :            :         struct ppl_header_entry entries[PPL_HDR_MAX_ENTRIES];
     431                 :            : } __attribute__ ((__packed__));
     432                 :            : 
     433                 :            : #endif