num_stripes
cols = num_stripes(max_t(u32, downsized_width, resized_width));
rows = num_stripes(max_t(u32, downsized_height, resized_height));
u32 num_stripes;
if (striped && candidate->iterator.num_stripes == 1) {
u8 num_stripes;
sh_css_sp_stage.num_stripes = (uint8_t)
sh_css_isp_stage.binary_info.iterator.num_stripes;
u8 num_stripes;
u32 num_stripes;
if (bi->info.isp.sp.iterator.num_stripes >
bi->info.isp.sp.iterator.num_stripes;
const unsigned int stripes = bi->info.isp.sp.iterator.num_stripes;
const unsigned int stripes = bi->info.isp.sp.iterator.num_stripes;
if (bi->info.isp.sp.iterator.num_stripes <= 1) {
stripes = bi->info.isp.sp.iterator.num_stripes ? : 1;
const unsigned int stripes = bi->info.isp.sp.iterator.num_stripes;
sp_stage->num_stripes = stripes;
BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
num_stripes, 16);
if (dev_nr == bioc->num_stripes - 1) {
int total_devs = bioc->num_stripes;
num_items = 3 + map->num_stripes;
buf = kzalloc_objs(u64, map->num_stripes, GFP_NOFS);
for (i = 0; i < map->num_stripes; i++) {
stripe_nr = div_u64(stripe_nr * map->num_stripes + i,
for (i = 0; i < map->num_stripes; i++) {
if (map->num_stripes == 0)
for (i = 0; i < map->num_stripes; i++) {
for (int i = 0; i < map->num_stripes; i++)
u16 num_stripes;
num_stripes = btrfs_stack_chunk_num_stripes(chunk);
if (unlikely(cur + btrfs_chunk_item_size(num_stripes) > sys_array_size))
cur += btrfs_chunk_item_size(num_stripes);
unsigned int num_stripes;
stripes = btrfs_map_discard(fs_info, cur, &num_bytes, &num_stripes,
for (i = 0; i < num_stripes; i++) {
map->num_stripes = 0;
const int num_stripes = btrfs_num_raid_stripes(item_size);
for (int i = 0; i < num_stripes; i++)
int num_stripes = btrfs_chunk_num_stripes(eb, chunk);
btrfs_chunk_type(eb, chunk), num_stripes);
for (i = 0 ; i < num_stripes ; i++) {
const int num_stripes = btrfs_bg_type_to_factor(bioc->map_type);
const size_t item_size = struct_size(stripe_extent, strides, num_stripes);
num_stripes);
for (int i = 0; i < num_stripes; i++) {
int num_stripes;
num_stripes = btrfs_num_raid_stripes(btrfs_item_size(leaf, slot));
for (int i = 0; i < num_stripes; i++) {
const unsigned int real_stripes = bioc->num_stripes - bioc->replace_nr_stripes;
ASSERT_RBIO_STRIPE(stripe_nr >= 0 && stripe_nr < rbio->bioc->num_stripes,
for (i = 0; i < bioc->num_stripes; i++) {
bioc->replace_stripe_src, bioc->num_stripes);
for (int i = 0; i < bioc->num_stripes; i++) {
return map->num_stripes - btrfs_nr_parity_stripes(map->type);
return bioc->num_stripes - btrfs_nr_parity_stripes(bioc->map_type);
num_items = chunk_map->num_stripes + 1;
num_items = 2 * chunk_map->num_stripes;
for (unsigned int i = 0; i < chunk_map->num_stripes; i++) {
rot = stripe_nr % map->num_stripes;
stripe_index = rot % map->num_stripes;
stripe_index = (i + rot) % map->num_stripes;
return btrfs_stripe_nr_to_offset(map->num_stripes / map->sub_stripes);
ASSERT(stripe_index < map->num_stripes);
ASSERT(stripe_index < map->num_stripes);
for (i = 0; i < map->num_stripes; ++i) {
int num_stripes = 1;
num_stripes = nr_devices;
num_stripes = rattr->ncopies;
num_stripes = 4;
num_stripes = min(num_stripes, nr_devices);
avail_space += devices_info[i].max_avail * num_stripes;
for (j = i + 1 - num_stripes; j <= i; j++)
u64 num_stripes;
map = btrfs_alloc_chunk_map(test->num_stripes, GFP_KERNEL);
map->num_stripes = test->num_stripes;
for (i = 0; i < map->num_stripes; i++) {
.num_stripes = 2,
.num_stripes = 1,
.num_stripes = 1,
.num_stripes = 2,
.num_stripes = 2,
.num_stripes = 2,
.num_stripes = 2,
.num_stripes = 2,
.num_stripes = 2,
.num_stripes = 2,
.num_stripes = 2,
u64 num_stripes;
.num_stripes = 2,
.num_stripes = 2,
.num_stripes = 2,
.num_stripes = 2,
.num_stripes = 4,
.num_stripes = 4,
.num_stripes = 2,
.num_stripes = 4,
.num_stripes = 4,
.num_stripes = 4,
.num_stripes = 2,
.num_stripes = 2,
.num_stripes = 2,
.num_stripes = 2,
.num_stripes = 4,
.num_stripes = 4,
.num_stripes = 4,
.num_stripes = 4,
.num_stripes = 4,
.num_stripes = 4,
.num_stripes = 8,
.num_stripes = 4,
.num_stripes = 4,
.num_stripes = 8,
.num_stripes = 8,
.num_stripes = 8,
.num_stripes = 4,
map = btrfs_alloc_chunk_map(test->num_stripes, GFP_KERNEL);
.num_stripes = 4,
.num_stripes = 4,
.num_stripes = 4,
.num_stripes = 8,
.num_stripes = 8,
zone_info = kzalloc_objs(*zone_info, test->num_stripes, GFP_KERNEL);
.num_stripes = 8,
.num_stripes = 8,
.num_stripes = 8,
active = bitmap_zalloc(test->num_stripes, GFP_KERNEL);
map->num_stripes = test->num_stripes;
for (int i = 0; i < test->num_stripes; i++) {
num_stripes, sub_stripes)) {
num_stripes, sub_stripes,
int num_stripes;
num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
if (num_stripes == 0)
if (unlikely(btrfs_chunk_item_size(num_stripes) !=
btrfs_chunk_item_size(num_stripes));
static bool valid_stripe_count(u64 profile, u16 num_stripes, u16 sub_stripes)
return num_stripes == btrfs_raid_array[BTRFS_RAID_RAID1].devs_min;
return num_stripes == btrfs_raid_array[BTRFS_RAID_RAID1C3].devs_min;
return num_stripes == btrfs_raid_array[BTRFS_RAID_RAID1C4].devs_min;
return num_stripes >= btrfs_raid_array[BTRFS_RAID_RAID5].devs_min;
return num_stripes >= btrfs_raid_array[BTRFS_RAID_RAID6].devs_min;
return num_stripes == btrfs_raid_array[BTRFS_RAID_DUP].dev_stripes;
return num_stripes == btrfs_raid_array[BTRFS_RAID_SINGLE].dev_stripes;
u16 num_stripes;
num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
num_stripes = btrfs_stack_chunk_num_stripes(chunk);
if (unlikely(!remapped && !num_stripes)) {
"invalid chunk num_stripes, have %u", num_stripes);
if (unlikely(num_stripes != 0 && num_stripes < ncopies)) {
num_stripes, ncopies);
if (unlikely(nparity && num_stripes == nparity)) {
num_stripes, nparity);
u32 num_stripes;
num_stripes = btrfs_stack_chunk_num_stripes(chunk);
len += btrfs_chunk_item_size(num_stripes);
for (i = 0; i < map->num_stripes; i++) {
for (i = 0; i < map->num_stripes; i++) {
int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
for (i = 0; i < num_stripes; i++) {
static u64 calc_data_stripes(u64 type, int num_stripes)
return (num_stripes - nparity) / ncopies;
int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
factor = calc_data_stripes(type, num_stripes);
for (i = 0; i < num_stripes; i++) {
int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
if (bargs->stripes_min <= num_stripes
&& num_stripes <= bargs->stripes_max)
int num_stripes;
int num_stripes;
ctl->num_stripes = ctl->ndevs * ctl->dev_stripes;
data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies;
ctl->num_stripes = ctl->ndevs * ctl->dev_stripes;
data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies;
ctl->num_stripes = ctl->ndevs * ctl->dev_stripes;
data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies;
for (int i = 0; i < map->num_stripes; i++) {
for (int i = 0; i < map->num_stripes; i++) {
struct btrfs_chunk_map *btrfs_alloc_chunk_map(int num_stripes, gfp_t gfp)
map = kmalloc(btrfs_chunk_map_size(num_stripes), gfp);
map = btrfs_alloc_chunk_map(ctl->num_stripes, GFP_NOFS);
map->num_stripes = ctl->num_stripes;
for (int i = 0; i < map->num_stripes; i++) {
atomic64_sub(ctl->stripe_size * map->num_stripes,
item_size = btrfs_chunk_item_size(map->num_stripes);
for (i = 0; i < map->num_stripes; i++) {
for (i = 0; i < map->num_stripes; i++) {
btrfs_set_stack_chunk_num_stripes(chunk, map->num_stripes);
for (i = 0; i < map->num_stripes; i++) {
return map->num_stripes;
static int btrfs_read_preferred(struct btrfs_chunk_map *map, int first, int num_stripes)
for (int index = first; index < first + num_stripes; index++) {
static int btrfs_read_rr(const struct btrfs_chunk_map *map, int first, int num_stripes)
for (int index = 0, i = first; i < first + num_stripes; i++) {
sort(stripes, num_stripes, sizeof(struct stripe_mirror),
return stripes[read_cycle % num_stripes].num;
int num_stripes;
num_stripes = map->sub_stripes;
num_stripes = map->num_stripes;
preferred_mirror = first + (current->pid % num_stripes);
preferred_mirror = btrfs_read_rr(map, first, num_stripes);
preferred_mirror = btrfs_read_preferred(map, first, num_stripes);
for (i = first; i < first + num_stripes; i++) {
u32 *num_stripes, bool do_remap)
*num_stripes = 1;
factor = map->num_stripes / sub_stripes;
*num_stripes = min_t(u64, map->num_stripes,
*num_stripes = map->num_stripes;
stripe_index = stripe_nr % map->num_stripes;
stripe_nr /= map->num_stripes;
stripes = kzalloc_objs(*stripes, *num_stripes, GFP_NOFS);
for (i = 0; i < *num_stripes; i++) {
if (stripe_index == map->num_stripes) {
int num_stripes = io_geom->num_stripes;
for (i = 0; i < num_stripes; i++) {
struct btrfs_io_stripe *new = &bioc->stripes[num_stripes + nr_extra_stripes];
struct btrfs_io_stripe *first = &bioc->stripes[num_stripes];
struct btrfs_io_stripe *second = &bioc->stripes[num_stripes + 1];
io_geom->num_stripes = num_stripes + nr_extra_stripes;
io_geom->stripe_index = io_geom->stripe_nr % map->num_stripes;
io_geom->stripe_nr /= map->num_stripes;
io_geom->num_stripes = map->num_stripes;
io_geom->num_stripes = map->num_stripes;
u32 factor = map->num_stripes / map->sub_stripes;
io_geom->num_stripes = map->sub_stripes;
io_geom->num_stripes = map->num_stripes;
(io_geom->stripe_nr + io_geom->stripe_index) % map->num_stripes;
io_geom->stripe_index = io_geom->stripe_nr % map->num_stripes;
io_geom->stripe_nr /= map->num_stripes;
io_geom.num_stripes = 1;
if (io_geom.stripe_index >= map->num_stripes) {
io_geom.stripe_index, map->num_stripes);
num_alloc_stripes = io_geom.num_stripes;
for (int i = 0; i < io_geom.num_stripes; i++) {
stripe_index = (i + io_geom.stripe_nr) % io_geom.num_stripes;
for (int i = 0; i < io_geom.num_stripes; i++) {
bioc->num_stripes = io_geom.num_stripes;
const int data_stripes = calc_data_stripes(map->type, map->num_stripes);
int num_stripes;
num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
map = btrfs_alloc_chunk_map(num_stripes, GFP_NOFS);
map->num_stripes = num_stripes;
if (num_stripes > 0)
for (i = 0; i < num_stripes; i++) {
for (i = 0; i < map->num_stripes; i++) {
for (i = 0; i < map->num_stripes; i++) {
if (map->verified_stripes >= map->num_stripes) {
if (unlikely(map->num_stripes != map->verified_stripes)) {
map->start, map->verified_stripes, map->num_stripes);
ASSERT(mirror_num <= bioc->num_stripes,
"mirror_num=%d num_stripes=%d", mirror_num, bioc->num_stripes);
u16 num_stripes;
int num_stripes;
static inline unsigned long btrfs_chunk_item_size(int num_stripes)
ASSERT(num_stripes);
sizeof(struct btrfs_stripe) * (num_stripes - 1);
u32 *num_stripes, bool do_remap);
struct btrfs_chunk_map *btrfs_alloc_chunk_map(int num_stripes, gfp_t gfp);
for (int i = 0; i < map->num_stripes; i++) {
for (i = 0; i < map->num_stripes; i++) {
for (i = 0; i < map->num_stripes; i++) {
for (int i = 0; i < map->num_stripes; i++) {
alloc = ((stripe_nr * map->num_stripes + i) << BTRFS_STRIPE_LEN_SHIFT) +
u32 factor = map->num_stripes;
for (int i = 0; i < map->num_stripes; i++) {
zone_info[map->num_stripes - 1].alloc_offset > BTRFS_STRIPE_LEN)) {
raid0_allocs = kzalloc_objs(*raid0_allocs, map->num_stripes / map->sub_stripes, GFP_NOFS);
for (int i = 0; i < map->num_stripes; i += map->sub_stripes) {
alloc = ((stripe_nr * (map->num_stripes / map->sub_stripes) +
u32 factor = map->num_stripes / map->sub_stripes;
for (int i = 0; i < map->num_stripes; i++) {
zone_info[map->num_stripes - 1].alloc_offset > BTRFS_STRIPE_LEN)) {
zone_info = kzalloc_objs(*zone_info, map->num_stripes, GFP_NOFS);
active = bitmap_zalloc(map->num_stripes, GFP_NOFS);
for (i = 0; i < map->num_stripes; i++) {
} else if (map->num_stripes == num_conventional) {
nmirrors = (int)bioc->num_stripes;
for (i = 0; i < map->num_stripes; i++) {
for (i = 0; i < map->num_stripes; i++) {
for (int i = 0; i < map->num_stripes; i++)
for (int i = 0; i < map->num_stripes; i++) {
__field( int, num_stripes )
__entry->num_stripes = map->num_stripes;
__entry->num_stripes, __entry->sub_stripes,
__entry->total_stripes = rbio->bioc->num_stripes;
int num_stripes),
TP_ARGS(fs_info, logical, length, num_stripes),
__field( int, num_stripes )
__entry->num_stripes = num_stripes;
__entry->num_stripes)
__le16 num_stripes;