smp: Fix rebase oopsies

Signed-off-by: Eric Naim <dnaim@cachyos.org>

Author: 1Naim

kernel/smp.c

@@ -649,12 +649,8 @@ void flush_smp_call_function_queue(void)
 }
 
 static int __smp_call_function_single(int cpu, smp_call_func_t func,
-<<<<<<< HEAD
-			void *info, const struct cpumask *mask, int wait)
-=======
 				      void *info, const struct cpumask *mask,
 				      bool wait)
->>>>>>> 7.2/preempt-ipi
 {
 	call_single_data_t *csd;
 	call_single_data_t csd_stack = {
@@ -726,17 +722,6 @@ static int __smp_call_function_single(int cpu, smp_call_func_t func,
 
 /**
  * smp_call_function_single - Run a function on a specific CPU
-<<<<<<< HEAD
- * @cpu: Specific target CPU for this function.
- * @func: The function to run. This must be fast and non-blocking.
- * @info: An arbitrary pointer to pass to the function.
- * @wait: If true, wait until function has completed on other CPUs.
- *
- * Returns: %0 on success, else a negative status code.
- */
-int smp_call_function_single(int cpu, smp_call_func_t func, void *info,
-			     int wait)
-=======
  * @cpu:	Specific target CPU for this function.
  * @func:	The function to run. This must be fast and non-blocking.
  * @info:	An arbitrary pointer to pass to the function.
@@ -745,7 +730,6 @@ int smp_call_function_single(int cpu, smp_call_func_t func, void *info,
  * Returns: %0 on success, else a negative status code.
  */
 int smp_call_function_single(int cpu, smp_call_func_t func, void *info, bool wait)
->>>>>>> 7.2/preempt-ipi
 {
 	return __smp_call_function_single(cpu, func, info, NULL, wait);
 }
@@ -874,29 +858,16 @@ static void smp_call_function_many_cond(const struct cpumask *mask,
 					unsigned int scf_flags,
 					smp_cond_func_t cond_func)
 {
-<<<<<<< HEAD
-	int cpu, last_cpu, this_cpu;
-	struct call_function_data *cfd;
-	bool wait = scf_flags & SCF_WAIT;
-	struct cpumask *cpumask, *task_mask;
-	int nr_cpus = 0;
-=======
 	struct cpumask *cpumask, *task_mask;
 	bool wait = scf_flags & SCF_WAIT;
 	struct call_function_data *cfd;
 	int cpu, last_cpu, this_cpu;
->>>>>>> 7.2/preempt-ipi
 	bool run_remote = false;
 	int nr_cpus = 0;
 
 	this_cpu = get_cpu();
-<<<<<<< HEAD
-	task_mask = smp_task_ipi_mask(current);
-	cfd = this_cpu_ptr(&cfd_data);
-=======
 	cfd = this_cpu_ptr(&cfd_data);
 	task_mask = smp_task_ipi_mask(current);
->>>>>>> 7.2/preempt-ipi
 	if (task_mask)
 		cpumask = task_mask;
 	else
@@ -981,17 +952,6 @@ static void smp_call_function_many_cond(const struct cpumask *mask,
 	}
 
 	/*
-<<<<<<< HEAD
-	 * Waiting for completion can take time, especially with many CPUs.
-	 * On a PREEMPT kernel a per-task cpumask is used to track CPUs with
-	 * pending IPI requests. This allows preemption to be enabled before
-	 * waiting. On a !PREEMPT kernel the cpumask is shared and the call
-	 * must block until completion to avoid modifications by another caller
-	 * on this CPU.
-	 */
-	if (task_mask)
-		put_cpu();
-=======
 	 * The IPI work has been queued and dispatched. On PREEMPT kernels,
 	 * tasks created through dup_task_struct() have task-local wait masks.
 	 * The boot init_task can fall back to cfd->cpumask when the mask is
@@ -1000,7 +960,6 @@ static void smp_call_function_many_cond(const struct cpumask *mask,
 	 * another task, so the per-CPU mask remains protected.
 	 */
 	put_cpu();
->>>>>>> 7.2/preempt-ipi
 
 	if (run_remote && wait) {
 		for_each_cpu(cpu, cpumask) {
@@ -1052,11 +1011,7 @@ EXPORT_SYMBOL(smp_call_function_many);
 void smp_call_function(smp_call_func_t func, void *info, int wait)
 {
 	smp_call_function_many_cond(cpu_online_mask, func, info,
-<<<<<<< HEAD
-			wait ? SCF_WAIT : 0, NULL);
-=======
 				    wait ? SCF_WAIT : 0, NULL);
->>>>>>> 7.2/preempt-ipi
 }
 EXPORT_SYMBOL(smp_call_function);