s390: Use generic idle thread allocation

	select ARCH_INLINE_WRITE_UNLOCK_BH

	select ARCH_INLINE_WRITE_UNLOCK_IRQ

	select ARCH_INLINE_WRITE_UNLOCK_IRQRESTORE

	select GENERIC_SMP_IDLE_THREAD

config SCHED_OMIT_FRAME_POINTER

	def_bool y

struct pcpu {

	struct cpu cpu;

	struct task_struct *idle;	/* idle process for the cpu */

	struct _lowcore *lowcore;	/* lowcore page(s) for the cpu */

	unsigned long async_stack;	/* async stack for the cpu */

	unsigned long panic_stack;	/* panic stack for the cpu */

	cpu_idle();

}

struct create_idle {

	struct work_struct work;

	struct task_struct *idle;

	struct completion done;

	int cpu;

};

static void __cpuinit smp_fork_idle(struct work_struct *work)

{

	struct create_idle *c_idle;

	c_idle = container_of(work, struct create_idle, work);

	c_idle->idle = fork_idle(c_idle->cpu);

	complete(&c_idle->done);

}

/* Upping and downing of CPUs */

int __cpuinit __cpu_up(unsigned int cpu, struct task_struct *tidle)

{

	struct create_idle c_idle;

	struct pcpu *pcpu;

	int rc;

	if (pcpu_sigp_retry(pcpu, sigp_initial_cpu_reset, 0) !=

	    sigp_order_code_accepted)

		return -EIO;

	if (!pcpu->idle) {

		c_idle.done = COMPLETION_INITIALIZER_ONSTACK(c_idle.done);

		INIT_WORK_ONSTACK(&c_idle.work, smp_fork_idle);

		c_idle.cpu = cpu;

		schedule_work(&c_idle.work);

		wait_for_completion(&c_idle.done);

		if (IS_ERR(c_idle.idle))

			return PTR_ERR(c_idle.idle);

		pcpu->idle = c_idle.idle;

	}

	init_idle(pcpu->idle, cpu);

	rc = pcpu_alloc_lowcore(pcpu, cpu);

	if (rc)

		return rc;

	pcpu_prepare_secondary(pcpu, cpu);

	pcpu_attach_task(pcpu, pcpu->idle);

	pcpu_attach_task(pcpu, tidle);

	pcpu_start_fn(pcpu, smp_start_secondary, NULL);

	while (!cpu_online(cpu))

		cpu_relax();

	struct pcpu *pcpu = pcpu_devices;

	boot_cpu_address = stap();

	pcpu->idle = current;

	pcpu->state = CPU_STATE_CONFIGURED;

	pcpu->address = boot_cpu_address;

	pcpu->lowcore = (struct _lowcore *)(unsigned long) store_prefix();