percpu: move chunk area map extension out of area allocation

}

/**

 * pcpu_split_block - split a map block

 * @chunk: chunk of interest

 * @i: index of map block to split

 * @head: head size in bytes (can be 0)

 * @tail: tail size in bytes (can be 0)

 *

 * Split the @i'th map block into two or three blocks.  If @head is

 * non-zero, @head bytes block is inserted before block @i moving it

 * to @i+1 and reducing its size by @head bytes.

 * pcpu_extend_area_map - extend area map for allocation

 * @chunk: target chunk

 *

 * If @tail is non-zero, the target block, which can be @i or @i+1

 * depending on @head, is reduced by @tail bytes and @tail byte block

 * is inserted after the target block.

 * Extend area map of @chunk so that it can accomodate an allocation.

 * A single allocation can split an area into three areas, so this

 * function makes sure that @chunk->map has at least two extra slots.

 *

 * RETURNS:

 * 0 on success, -errno on failure.

 * 0 if noop, 1 if successfully extended, -errno on failure.

 */

static int pcpu_split_block(struct pcpu_chunk *chunk, int i, int head, int tail)

static int pcpu_extend_area_map(struct pcpu_chunk *chunk)

{

	int nr_extra = !!head + !!tail;

	int target = chunk->map_used + nr_extra;

	/* reallocation required? */

	if (chunk->map_alloc < target) {

	int new_alloc;

	int *new;

	size_t size;

	/* has enough? */

	if (chunk->map_alloc >= chunk->map_used + 2)

		return 0;

	new_alloc = PCPU_DFL_MAP_ALLOC;

		while (new_alloc < target)

	while (new_alloc < chunk->map_used + 2)

		new_alloc *= 2;

	new = pcpu_mem_alloc(new_alloc * sizeof(new[0]));

	memcpy(new, chunk->map, size);

	/*

		 * map_alloc < PCPU_DFL_MAP_ALLOC indicates that the

		 * chunk is one of the first chunks and still using

		 * static map.

	 * map_alloc < PCPU_DFL_MAP_ALLOC indicates that the chunk is

	 * one of the first chunks and still using static map.

	 */

	if (chunk->map_alloc >= PCPU_DFL_MAP_ALLOC)

		pcpu_mem_free(chunk->map, size);

	chunk->map_alloc = new_alloc;

	chunk->map = new;

	return 0;

}

	/* insert a new subblock */

/**

 * pcpu_split_block - split a map block

 * @chunk: chunk of interest

 * @i: index of map block to split

 * @head: head size in bytes (can be 0)

 * @tail: tail size in bytes (can be 0)

 *

 * Split the @i'th map block into two or three blocks.  If @head is

 * non-zero, @head bytes block is inserted before block @i moving it

 * to @i+1 and reducing its size by @head bytes.

 *

 * If @tail is non-zero, the target block, which can be @i or @i+1

 * depending on @head, is reduced by @tail bytes and @tail byte block

 * is inserted after the target block.

 *

 * @chunk->map must have enough free slots to accomodate the split.

 */

static void pcpu_split_block(struct pcpu_chunk *chunk, int i,

			     int head, int tail)

{

	int nr_extra = !!head + !!tail;

	BUG_ON(chunk->map_alloc < chunk->map_used + nr_extra);

	/* insert new subblocks */

	memmove(&chunk->map[i + nr_extra], &chunk->map[i],

		sizeof(chunk->map[0]) * (chunk->map_used - i));

	chunk->map_used += nr_extra;

		chunk->map[i++] -= tail;

		chunk->map[i] = tail;

	}

	return 0;

}

/**

 * Note that this function only allocates the offset.  It doesn't

 * populate or map the area.

 *

 * @chunk->map must have at least two free slots.

 *

 * RETURNS:

 * Allocated offset in @chunk on success, -errno on failure.

 * Allocated offset in @chunk on success, -1 if no matching area is

 * found.

 */

static int pcpu_alloc_area(struct pcpu_chunk *chunk, int size, int align)

{

		/* split if warranted */

		if (head || tail) {

			if (pcpu_split_block(chunk, i, head, tail))

				return -ENOMEM;

			pcpu_split_block(chunk, i, head, tail);

			if (head) {

				i++;

				off += head;

	chunk->contig_hint = max_contig;	/* fully scanned */

	pcpu_chunk_relocate(chunk, oslot);

	/*

	 * Tell the upper layer that this chunk has no area left.

	 * Note that this is not an error condition but a notification

	 * to upper layer that it needs to look at other chunks.

	 * -ENOSPC is chosen as it isn't used in memory subsystem and

	 * matches the meaning in a way.

	 */

	return -ENOSPC;

	/* tell the upper layer that this chunk has no matching area */

	return -1;

}

/**

	/* serve reserved allocations from the reserved chunk if available */

	if (reserved && pcpu_reserved_chunk) {

		chunk = pcpu_reserved_chunk;

		if (size > chunk->contig_hint)

		if (size > chunk->contig_hint ||

		    pcpu_extend_area_map(chunk) < 0)

			goto out_unlock;

		off = pcpu_alloc_area(chunk, size, align);

		if (off >= 0)

		list_for_each_entry(chunk, &pcpu_slot[slot], list) {

			if (size > chunk->contig_hint)

				continue;

			if (pcpu_extend_area_map(chunk) < 0)

				goto out_unlock;

			off = pcpu_alloc_area(chunk, size, align);

			if (off >= 0)

				goto area_found;

			if (off != -ENOSPC)

				goto out_unlock;

		}

	}