Merge tag 'renesas-dt-fixes-for-v4.15' of https://git.kernel.org/pub/scm/linux/kernel...
[sfrench/cifs-2.6.git] / kernel / reboot.c
1 /*
2  *  linux/kernel/reboot.c
3  *
4  *  Copyright (C) 2013  Linus Torvalds
5  */
6
7 #define pr_fmt(fmt)     "reboot: " fmt
8
9 #include <linux/ctype.h>
10 #include <linux/export.h>
11 #include <linux/kexec.h>
12 #include <linux/kmod.h>
13 #include <linux/kmsg_dump.h>
14 #include <linux/reboot.h>
15 #include <linux/suspend.h>
16 #include <linux/syscalls.h>
17 #include <linux/syscore_ops.h>
18 #include <linux/uaccess.h>
19
20 /*
21  * this indicates whether you can reboot with ctrl-alt-del: the default is yes
22  */
23
24 int C_A_D = 1;
25 struct pid *cad_pid;
26 EXPORT_SYMBOL(cad_pid);
27
28 #if defined(CONFIG_ARM) || defined(CONFIG_UNICORE32)
29 #define DEFAULT_REBOOT_MODE             = REBOOT_HARD
30 #else
31 #define DEFAULT_REBOOT_MODE
32 #endif
33 enum reboot_mode reboot_mode DEFAULT_REBOOT_MODE;
34
35 /*
36  * This variable is used privately to keep track of whether or not
37  * reboot_type is still set to its default value (i.e., reboot= hasn't
38  * been set on the command line).  This is needed so that we can
39  * suppress DMI scanning for reboot quirks.  Without it, it's
40  * impossible to override a faulty reboot quirk without recompiling.
41  */
42 int reboot_default = 1;
43 int reboot_cpu;
44 enum reboot_type reboot_type = BOOT_ACPI;
45 int reboot_force;
46
47 /*
48  * If set, this is used for preparing the system to power off.
49  */
50
51 void (*pm_power_off_prepare)(void);
52
53 /**
54  *      emergency_restart - reboot the system
55  *
56  *      Without shutting down any hardware or taking any locks
57  *      reboot the system.  This is called when we know we are in
58  *      trouble so this is our best effort to reboot.  This is
59  *      safe to call in interrupt context.
60  */
61 void emergency_restart(void)
62 {
63         kmsg_dump(KMSG_DUMP_EMERG);
64         machine_emergency_restart();
65 }
66 EXPORT_SYMBOL_GPL(emergency_restart);
67
68 void kernel_restart_prepare(char *cmd)
69 {
70         blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
71         system_state = SYSTEM_RESTART;
72         usermodehelper_disable();
73         device_shutdown();
74 }
75
76 /**
77  *      register_reboot_notifier - Register function to be called at reboot time
78  *      @nb: Info about notifier function to be called
79  *
80  *      Registers a function with the list of functions
81  *      to be called at reboot time.
82  *
83  *      Currently always returns zero, as blocking_notifier_chain_register()
84  *      always returns zero.
85  */
86 int register_reboot_notifier(struct notifier_block *nb)
87 {
88         return blocking_notifier_chain_register(&reboot_notifier_list, nb);
89 }
90 EXPORT_SYMBOL(register_reboot_notifier);
91
92 /**
93  *      unregister_reboot_notifier - Unregister previously registered reboot notifier
94  *      @nb: Hook to be unregistered
95  *
96  *      Unregisters a previously registered reboot
97  *      notifier function.
98  *
99  *      Returns zero on success, or %-ENOENT on failure.
100  */
101 int unregister_reboot_notifier(struct notifier_block *nb)
102 {
103         return blocking_notifier_chain_unregister(&reboot_notifier_list, nb);
104 }
105 EXPORT_SYMBOL(unregister_reboot_notifier);
106
107 static void devm_unregister_reboot_notifier(struct device *dev, void *res)
108 {
109         WARN_ON(unregister_reboot_notifier(*(struct notifier_block **)res));
110 }
111
112 int devm_register_reboot_notifier(struct device *dev, struct notifier_block *nb)
113 {
114         struct notifier_block **rcnb;
115         int ret;
116
117         rcnb = devres_alloc(devm_unregister_reboot_notifier,
118                             sizeof(*rcnb), GFP_KERNEL);
119         if (!rcnb)
120                 return -ENOMEM;
121
122         ret = register_reboot_notifier(nb);
123         if (!ret) {
124                 *rcnb = nb;
125                 devres_add(dev, rcnb);
126         } else {
127                 devres_free(rcnb);
128         }
129
130         return ret;
131 }
132 EXPORT_SYMBOL(devm_register_reboot_notifier);
133
134 /*
135  *      Notifier list for kernel code which wants to be called
136  *      to restart the system.
137  */
138 static ATOMIC_NOTIFIER_HEAD(restart_handler_list);
139
140 /**
141  *      register_restart_handler - Register function to be called to reset
142  *                                 the system
143  *      @nb: Info about handler function to be called
144  *      @nb->priority:  Handler priority. Handlers should follow the
145  *                      following guidelines for setting priorities.
146  *                      0:      Restart handler of last resort,
147  *                              with limited restart capabilities
148  *                      128:    Default restart handler; use if no other
149  *                              restart handler is expected to be available,
150  *                              and/or if restart functionality is
151  *                              sufficient to restart the entire system
152  *                      255:    Highest priority restart handler, will
153  *                              preempt all other restart handlers
154  *
155  *      Registers a function with code to be called to restart the
156  *      system.
157  *
158  *      Registered functions will be called from machine_restart as last
159  *      step of the restart sequence (if the architecture specific
160  *      machine_restart function calls do_kernel_restart - see below
161  *      for details).
162  *      Registered functions are expected to restart the system immediately.
163  *      If more than one function is registered, the restart handler priority
164  *      selects which function will be called first.
165  *
166  *      Restart handlers are expected to be registered from non-architecture
167  *      code, typically from drivers. A typical use case would be a system
168  *      where restart functionality is provided through a watchdog. Multiple
169  *      restart handlers may exist; for example, one restart handler might
170  *      restart the entire system, while another only restarts the CPU.
171  *      In such cases, the restart handler which only restarts part of the
172  *      hardware is expected to register with low priority to ensure that
173  *      it only runs if no other means to restart the system is available.
174  *
175  *      Currently always returns zero, as atomic_notifier_chain_register()
176  *      always returns zero.
177  */
178 int register_restart_handler(struct notifier_block *nb)
179 {
180         return atomic_notifier_chain_register(&restart_handler_list, nb);
181 }
182 EXPORT_SYMBOL(register_restart_handler);
183
184 /**
185  *      unregister_restart_handler - Unregister previously registered
186  *                                   restart handler
187  *      @nb: Hook to be unregistered
188  *
189  *      Unregisters a previously registered restart handler function.
190  *
191  *      Returns zero on success, or %-ENOENT on failure.
192  */
193 int unregister_restart_handler(struct notifier_block *nb)
194 {
195         return atomic_notifier_chain_unregister(&restart_handler_list, nb);
196 }
197 EXPORT_SYMBOL(unregister_restart_handler);
198
199 /**
200  *      do_kernel_restart - Execute kernel restart handler call chain
201  *
202  *      Calls functions registered with register_restart_handler.
203  *
204  *      Expected to be called from machine_restart as last step of the restart
205  *      sequence.
206  *
207  *      Restarts the system immediately if a restart handler function has been
208  *      registered. Otherwise does nothing.
209  */
210 void do_kernel_restart(char *cmd)
211 {
212         atomic_notifier_call_chain(&restart_handler_list, reboot_mode, cmd);
213 }
214
215 void migrate_to_reboot_cpu(void)
216 {
217         /* The boot cpu is always logical cpu 0 */
218         int cpu = reboot_cpu;
219
220         cpu_hotplug_disable();
221
222         /* Make certain the cpu I'm about to reboot on is online */
223         if (!cpu_online(cpu))
224                 cpu = cpumask_first(cpu_online_mask);
225
226         /* Prevent races with other tasks migrating this task */
227         current->flags |= PF_NO_SETAFFINITY;
228
229         /* Make certain I only run on the appropriate processor */
230         set_cpus_allowed_ptr(current, cpumask_of(cpu));
231 }
232
233 /**
234  *      kernel_restart - reboot the system
235  *      @cmd: pointer to buffer containing command to execute for restart
236  *              or %NULL
237  *
238  *      Shutdown everything and perform a clean reboot.
239  *      This is not safe to call in interrupt context.
240  */
241 void kernel_restart(char *cmd)
242 {
243         kernel_restart_prepare(cmd);
244         migrate_to_reboot_cpu();
245         syscore_shutdown();
246         if (!cmd)
247                 pr_emerg("Restarting system\n");
248         else
249                 pr_emerg("Restarting system with command '%s'\n", cmd);
250         kmsg_dump(KMSG_DUMP_RESTART);
251         machine_restart(cmd);
252 }
253 EXPORT_SYMBOL_GPL(kernel_restart);
254
255 static void kernel_shutdown_prepare(enum system_states state)
256 {
257         blocking_notifier_call_chain(&reboot_notifier_list,
258                 (state == SYSTEM_HALT) ? SYS_HALT : SYS_POWER_OFF, NULL);
259         system_state = state;
260         usermodehelper_disable();
261         device_shutdown();
262 }
263 /**
264  *      kernel_halt - halt the system
265  *
266  *      Shutdown everything and perform a clean system halt.
267  */
268 void kernel_halt(void)
269 {
270         kernel_shutdown_prepare(SYSTEM_HALT);
271         migrate_to_reboot_cpu();
272         syscore_shutdown();
273         pr_emerg("System halted\n");
274         kmsg_dump(KMSG_DUMP_HALT);
275         machine_halt();
276 }
277 EXPORT_SYMBOL_GPL(kernel_halt);
278
279 /**
280  *      kernel_power_off - power_off the system
281  *
282  *      Shutdown everything and perform a clean system power_off.
283  */
284 void kernel_power_off(void)
285 {
286         kernel_shutdown_prepare(SYSTEM_POWER_OFF);
287         if (pm_power_off_prepare)
288                 pm_power_off_prepare();
289         migrate_to_reboot_cpu();
290         syscore_shutdown();
291         pr_emerg("Power down\n");
292         kmsg_dump(KMSG_DUMP_POWEROFF);
293         machine_power_off();
294 }
295 EXPORT_SYMBOL_GPL(kernel_power_off);
296
297 static DEFINE_MUTEX(reboot_mutex);
298
299 /*
300  * Reboot system call: for obvious reasons only root may call it,
301  * and even root needs to set up some magic numbers in the registers
302  * so that some mistake won't make this reboot the whole machine.
303  * You can also set the meaning of the ctrl-alt-del-key here.
304  *
305  * reboot doesn't sync: do that yourself before calling this.
306  */
307 SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
308                 void __user *, arg)
309 {
310         struct pid_namespace *pid_ns = task_active_pid_ns(current);
311         char buffer[256];
312         int ret = 0;
313
314         /* We only trust the superuser with rebooting the system. */
315         if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT))
316                 return -EPERM;
317
318         /* For safety, we require "magic" arguments. */
319         if (magic1 != LINUX_REBOOT_MAGIC1 ||
320                         (magic2 != LINUX_REBOOT_MAGIC2 &&
321                         magic2 != LINUX_REBOOT_MAGIC2A &&
322                         magic2 != LINUX_REBOOT_MAGIC2B &&
323                         magic2 != LINUX_REBOOT_MAGIC2C))
324                 return -EINVAL;
325
326         /*
327          * If pid namespaces are enabled and the current task is in a child
328          * pid_namespace, the command is handled by reboot_pid_ns() which will
329          * call do_exit().
330          */
331         ret = reboot_pid_ns(pid_ns, cmd);
332         if (ret)
333                 return ret;
334
335         /* Instead of trying to make the power_off code look like
336          * halt when pm_power_off is not set do it the easy way.
337          */
338         if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)
339                 cmd = LINUX_REBOOT_CMD_HALT;
340
341         mutex_lock(&reboot_mutex);
342         switch (cmd) {
343         case LINUX_REBOOT_CMD_RESTART:
344                 kernel_restart(NULL);
345                 break;
346
347         case LINUX_REBOOT_CMD_CAD_ON:
348                 C_A_D = 1;
349                 break;
350
351         case LINUX_REBOOT_CMD_CAD_OFF:
352                 C_A_D = 0;
353                 break;
354
355         case LINUX_REBOOT_CMD_HALT:
356                 kernel_halt();
357                 do_exit(0);
358                 panic("cannot halt");
359
360         case LINUX_REBOOT_CMD_POWER_OFF:
361                 kernel_power_off();
362                 do_exit(0);
363                 break;
364
365         case LINUX_REBOOT_CMD_RESTART2:
366                 ret = strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1);
367                 if (ret < 0) {
368                         ret = -EFAULT;
369                         break;
370                 }
371                 buffer[sizeof(buffer) - 1] = '\0';
372
373                 kernel_restart(buffer);
374                 break;
375
376 #ifdef CONFIG_KEXEC_CORE
377         case LINUX_REBOOT_CMD_KEXEC:
378                 ret = kernel_kexec();
379                 break;
380 #endif
381
382 #ifdef CONFIG_HIBERNATION
383         case LINUX_REBOOT_CMD_SW_SUSPEND:
384                 ret = hibernate();
385                 break;
386 #endif
387
388         default:
389                 ret = -EINVAL;
390                 break;
391         }
392         mutex_unlock(&reboot_mutex);
393         return ret;
394 }
395
396 static void deferred_cad(struct work_struct *dummy)
397 {
398         kernel_restart(NULL);
399 }
400
401 /*
402  * This function gets called by ctrl-alt-del - ie the keyboard interrupt.
403  * As it's called within an interrupt, it may NOT sync: the only choice
404  * is whether to reboot at once, or just ignore the ctrl-alt-del.
405  */
406 void ctrl_alt_del(void)
407 {
408         static DECLARE_WORK(cad_work, deferred_cad);
409
410         if (C_A_D)
411                 schedule_work(&cad_work);
412         else
413                 kill_cad_pid(SIGINT, 1);
414 }
415
416 char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff";
417 static const char reboot_cmd[] = "/sbin/reboot";
418
419 static int run_cmd(const char *cmd)
420 {
421         char **argv;
422         static char *envp[] = {
423                 "HOME=/",
424                 "PATH=/sbin:/bin:/usr/sbin:/usr/bin",
425                 NULL
426         };
427         int ret;
428         argv = argv_split(GFP_KERNEL, cmd, NULL);
429         if (argv) {
430                 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
431                 argv_free(argv);
432         } else {
433                 ret = -ENOMEM;
434         }
435
436         return ret;
437 }
438
439 static int __orderly_reboot(void)
440 {
441         int ret;
442
443         ret = run_cmd(reboot_cmd);
444
445         if (ret) {
446                 pr_warn("Failed to start orderly reboot: forcing the issue\n");
447                 emergency_sync();
448                 kernel_restart(NULL);
449         }
450
451         return ret;
452 }
453
454 static int __orderly_poweroff(bool force)
455 {
456         int ret;
457
458         ret = run_cmd(poweroff_cmd);
459
460         if (ret && force) {
461                 pr_warn("Failed to start orderly shutdown: forcing the issue\n");
462
463                 /*
464                  * I guess this should try to kick off some daemon to sync and
465                  * poweroff asap.  Or not even bother syncing if we're doing an
466                  * emergency shutdown?
467                  */
468                 emergency_sync();
469                 kernel_power_off();
470         }
471
472         return ret;
473 }
474
475 static bool poweroff_force;
476
477 static void poweroff_work_func(struct work_struct *work)
478 {
479         __orderly_poweroff(poweroff_force);
480 }
481
482 static DECLARE_WORK(poweroff_work, poweroff_work_func);
483
484 /**
485  * orderly_poweroff - Trigger an orderly system poweroff
486  * @force: force poweroff if command execution fails
487  *
488  * This may be called from any context to trigger a system shutdown.
489  * If the orderly shutdown fails, it will force an immediate shutdown.
490  */
491 void orderly_poweroff(bool force)
492 {
493         if (force) /* do not override the pending "true" */
494                 poweroff_force = true;
495         schedule_work(&poweroff_work);
496 }
497 EXPORT_SYMBOL_GPL(orderly_poweroff);
498
499 static void reboot_work_func(struct work_struct *work)
500 {
501         __orderly_reboot();
502 }
503
504 static DECLARE_WORK(reboot_work, reboot_work_func);
505
506 /**
507  * orderly_reboot - Trigger an orderly system reboot
508  *
509  * This may be called from any context to trigger a system reboot.
510  * If the orderly reboot fails, it will force an immediate reboot.
511  */
512 void orderly_reboot(void)
513 {
514         schedule_work(&reboot_work);
515 }
516 EXPORT_SYMBOL_GPL(orderly_reboot);
517
518 static int __init reboot_setup(char *str)
519 {
520         for (;;) {
521                 /*
522                  * Having anything passed on the command line via
523                  * reboot= will cause us to disable DMI checking
524                  * below.
525                  */
526                 reboot_default = 0;
527
528                 switch (*str) {
529                 case 'w':
530                         reboot_mode = REBOOT_WARM;
531                         break;
532
533                 case 'c':
534                         reboot_mode = REBOOT_COLD;
535                         break;
536
537                 case 'h':
538                         reboot_mode = REBOOT_HARD;
539                         break;
540
541                 case 's':
542                 {
543                         int rc;
544
545                         if (isdigit(*(str+1))) {
546                                 rc = kstrtoint(str+1, 0, &reboot_cpu);
547                                 if (rc)
548                                         return rc;
549                         } else if (str[1] == 'm' && str[2] == 'p' &&
550                                    isdigit(*(str+3))) {
551                                 rc = kstrtoint(str+3, 0, &reboot_cpu);
552                                 if (rc)
553                                         return rc;
554                         } else
555                                 reboot_mode = REBOOT_SOFT;
556                         break;
557                 }
558                 case 'g':
559                         reboot_mode = REBOOT_GPIO;
560                         break;
561
562                 case 'b':
563                 case 'a':
564                 case 'k':
565                 case 't':
566                 case 'e':
567                 case 'p':
568                         reboot_type = *str;
569                         break;
570
571                 case 'f':
572                         reboot_force = 1;
573                         break;
574                 }
575
576                 str = strchr(str, ',');
577                 if (str)
578                         str++;
579                 else
580                         break;
581         }
582         return 1;
583 }
584 __setup("reboot=", reboot_setup);