Print this page
```3742 zfs comments need cleaner, more consistent style
Submitted by:   Will Andrews <willa@spectralogic.com>
Submitted by:   Alan Somers <alans@spectralogic.com>
Reviewed by:    Matthew Ahrens <mahrens@delphix.com>
Reviewed by:    George Wilson <george.wilson@delphix.com>
Reviewed by:    Eric Schrock <eric.schrock@delphix.com>
```

 Split Close Expand all Collapse all
```          --- old/usr/src/uts/common/fs/zfs/vdev_raidz.c
+++ new/usr/src/uts/common/fs/zfs/vdev_raidz.c
```
 ↓ open down ↓ 52 lines elided ↑ open up ↑
```  53   53   * suffer.
54   54   *
55   55   * All of the methods above operate on a Galois field, defined over the
56   56   * integers mod 2^N. In our case we choose N=8 for GF(8) so that all elements
57   57   * can be expressed with a single byte. Briefly, the operations on the
58   58   * field are defined as follows:
59   59   *
60   60   *   o addition (+) is represented by a bitwise XOR
61   61   *   o subtraction (-) is therefore identical to addition: A + B = A - B
62   62   *   o multiplication of A by 2 is defined by the following bitwise expression:
63 + *
63   64   *      (A * 2)_7 = A_6
64   65   *      (A * 2)_6 = A_5
65   66   *      (A * 2)_5 = A_4
66   67   *      (A * 2)_4 = A_3 + A_7
67   68   *      (A * 2)_3 = A_2 + A_7
68   69   *      (A * 2)_2 = A_1 + A_7
69   70   *      (A * 2)_1 = A_0
70   71   *      (A * 2)_0 = A_7
71   72   *
72   73   * In C, multiplying by 2 is therefore ((a << 1) ^ ((a & 0x80) ? 0x1d : 0)).
```
 ↓ open down ↓ 38 lines elided ↑ open up ↑
``` 111  112
112  113  typedef struct raidz_map {
113  114          uint64_t rm_cols;               /* Regular column count */
114  115          uint64_t rm_scols;              /* Count including skipped columns */
115  116          uint64_t rm_bigcols;            /* Number of oversized columns */
116  117          uint64_t rm_asize;              /* Actual total I/O size */
117  118          uint64_t rm_missingdata;        /* Count of missing data devices */
118  119          uint64_t rm_missingparity;      /* Count of missing parity devices */
119  120          uint64_t rm_firstdatacol;       /* First data column/parity count */
120  121          uint64_t rm_nskip;              /* Skipped sectors for padding */
121      -        uint64_t rm_skipstart;  /* Column index of padding start */
122 +        uint64_t rm_skipstart;          /* Column index of padding start */
122  123          void *rm_datacopy;              /* rm_asize-buffer of copied data */
123  124          uintptr_t rm_reports;           /* # of referencing checksum reports */
124  125          uint8_t rm_freed;               /* map no longer has referencing ZIO */
125  126          uint8_t rm_ecksuminjected;      /* checksum error was injected */
126  127          raidz_col_t rm_col[1];          /* Flexible array of I/O columns */
127  128  } raidz_map_t;
128  129
129  130  #define VDEV_RAIDZ_P            0
130  131  #define VDEV_RAIDZ_Q            1
131  132  #define VDEV_RAIDZ_R            2
```
 ↓ open down ↓ 19 lines elided ↑ open up ↑
``` 151  152  { \
152  153          VDEV_RAIDZ_64MUL_2((x), mask); \
153  154          VDEV_RAIDZ_64MUL_2((x), mask); \
154  155  }
155  156
156  157  /*
157  158   * Force reconstruction to use the general purpose method.
158  159   */
159  160  int vdev_raidz_default_to_general;
160  161
161      -/*
162      - * These two tables represent powers and logs of 2 in the Galois field defined
163      - * above. These values were computed by repeatedly multiplying by 2 as above.
164      - */
162 +/* Powers of 2 in the Galois field defined above. */
165  163  static const uint8_t vdev_raidz_pow2[256] = {
166  164          0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
167  165          0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
168  166          0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9,
169  167          0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
170  168          0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35,
171  169          0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
172  170          0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0,
173  171          0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
174  172          0x5f, 0xbe, 0x61, 0xc2, 0x99, 0x2f, 0x5e, 0xbc,
```
 ↓ open down ↓ 14 lines elided ↑ open up ↑
``` 189  187          0x95, 0x37, 0x6e, 0xdc, 0xa5, 0x57, 0xae, 0x41,
190  188          0x82, 0x19, 0x32, 0x64, 0xc8, 0x8d, 0x07, 0x0e,
191  189          0x1c, 0x38, 0x70, 0xe0, 0xdd, 0xa7, 0x53, 0xa6,
192  190          0x51, 0xa2, 0x59, 0xb2, 0x79, 0xf2, 0xf9, 0xef,
193  191          0xc3, 0x9b, 0x2b, 0x56, 0xac, 0x45, 0x8a, 0x09,
194  192          0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5,
195  193          0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
196  194          0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83,
197  195          0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x01
198  196  };
197 +/* Logs of 2 in the Galois field defined above. */
199  198  static const uint8_t vdev_raidz_log2[256] = {
200  199          0x00, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6,
201  200          0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
202  201          0x04, 0x64, 0xe0, 0x0e, 0x34, 0x8d, 0xef, 0x81,
203  202          0x1c, 0xc1, 0x69, 0xf8, 0xc8, 0x08, 0x4c, 0x71,
204  203          0x05, 0x8a, 0x65, 0x2f, 0xe1, 0x24, 0x0f, 0x21,
205  204          0x35, 0x93, 0x8e, 0xda, 0xf0, 0x12, 0x82, 0x45,
206  205          0x1d, 0xb5, 0xc2, 0x7d, 0x6a, 0x27, 0xf9, 0xb9,
207  206          0xc9, 0x9a, 0x09, 0x78, 0x4d, 0xe4, 0x72, 0xa6,
208  207          0x06, 0xbf, 0x8b, 0x62, 0x66, 0xdd, 0x30, 0xfd,
```
 ↓ open down ↓ 2008 lines elided ↑ open up ↑
`XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX`