/*
* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012 by Delphix. All rights reserved.
*/
#include <sys/zfs_context.h>
ASSERT3U(acols, <=, scols);
- rm = kmem_alloc(offsetof(raidz_map_t, rm_col[scols]), KM_SLEEP);
+ rm = kmem_alloc(offsetof(raidz_map_t, rm_col[scols]), KM_PUSHPAGE);
rm->rm_cols = acols;
rm->rm_scols = scols;
size_t psize;
psize = sizeof (invlog[0][0]) * n * nmissing;
- p = kmem_alloc(psize, KM_SLEEP);
+ p = kmem_alloc(psize, KM_PUSHPAGE);
for (pp = p, i = 0; i < nmissing; i++) {
invlog[i] = pp;
psize = (sizeof (rows[0][0]) + sizeof (invrows[0][0])) *
nmissing_rows * n + sizeof (used[0]) * n;
- p = kmem_alloc(psize, KM_SLEEP);
+ p = kmem_alloc(psize, KM_PUSHPAGE);
for (pp = p, i = 0; i < nmissing_rows; i++) {
rows[i] = pp;
}
static int
-vdev_raidz_open(vdev_t *vd, uint64_t *asize, uint64_t *ashift)
+vdev_raidz_open(vdev_t *vd, uint64_t *asize, uint64_t *max_asize,
+ uint64_t *ashift)
{
vdev_t *cvd;
uint64_t nparity = vd->vdev_nparity;
}
*asize = MIN(*asize - 1, cvd->vdev_asize - 1) + 1;
+ *max_asize = MIN(*max_asize - 1, cvd->vdev_max_asize - 1) + 1;
*ashift = MAX(*ashift, cvd->vdev_ashift);
}
*asize *= vd->vdev_children;
+ *max_asize *= vd->vdev_children;
if (numerrors > nparity) {
vd->vdev_stat.vs_aux = VDEV_AUX_NO_REPLICAS;
void *orig[VDEV_RAIDZ_MAXPARITY];
int tstore[VDEV_RAIDZ_MAXPARITY + 2];
int *tgts = &tstore[1];
- int current, next, i, c, n;
+ int curr, next, i, c, n;
int code, ret = 0;
ASSERT(total_errors < rm->rm_firstdatacol);
orig[n - 1] = zio_buf_alloc(rm->rm_col[0].rc_size);
- current = 0;
- next = tgts[current];
+ curr = 0;
+ next = tgts[curr];
- while (current != n) {
- tgts[current] = next;
- current = 0;
+ while (curr != n) {
+ tgts[curr] = next;
+ curr = 0;
/*
* Save off the original data that we're going to
do {
/*
- * Find the next valid column after the current
+ * Find the next valid column after the curr
* position..
*/
- for (next = tgts[current] + 1;
+ for (next = tgts[curr] + 1;
next < rm->rm_cols &&
rm->rm_col[next].rc_error != 0; next++)
continue;
- ASSERT(next <= tgts[current + 1]);
+ ASSERT(next <= tgts[curr + 1]);
/*
* If that spot is available, we're done here.
*/
- if (next != tgts[current + 1])
+ if (next != tgts[curr + 1])
break;
/*
* Otherwise, find the next valid column after
* the previous position.
*/
- for (c = tgts[current - 1] + 1;
+ for (c = tgts[curr - 1] + 1;
rm->rm_col[c].rc_error != 0; c++)
continue;
- tgts[current] = c;
- current++;
+ tgts[curr] = c;
+ curr++;
- } while (current != n);
+ } while (curr != n);
}
}
n--;