a43dd676494a18e28dab0ea53b7029898644e07d
[petitboot] / discover / platform-powerpc.c
1
2 #include <assert.h>
3 #include <string.h>
4 #include <stdlib.h>
5 #include <errno.h>
6 #include <fcntl.h>
7 #include <sys/types.h>
8 #include <sys/wait.h>
9 #include <sys/stat.h>
10 #include <asm/byteorder.h>
11
12 #include <file/file.h>
13 #include <talloc/talloc.h>
14 #include <list/list.h>
15 #include <log/log.h>
16 #include <process/process.h>
17 #include <crypt/crypt.h>
18
19 #include "hostboot.h"
20 #include "platform.h"
21 #include "ipmi.h"
22 #include "dt.h"
23
24 static const char *partition = "common";
25 static const char *sysparams_dir = "/sys/firmware/opal/sysparams/";
26 static const char *devtree_dir = "/proc/device-tree/";
27
28 struct platform_powerpc {
29         struct param_list *params;
30         struct ipmi     *ipmi;
31         int             (*get_ipmi_bootdev)(
32                                 struct platform_powerpc *platform,
33                                 uint8_t *bootdev, bool *persistent);
34         int             (*clear_ipmi_bootdev)(
35                                 struct platform_powerpc *platform,
36                                 bool persistent);
37         int             (*set_os_boot_sensor)(
38                                 struct platform_powerpc *platform);
39         void            (*get_platform_versions)(struct system_info *info);
40 };
41
42 #define to_platform_powerpc(p) \
43         (struct platform_powerpc *)(p->platform_data)
44
45 static int parse_nvram_params(struct platform_powerpc *platform,
46                 char *buf, int len)
47 {
48         char *pos, *name, *value;
49         unsigned int paramlen;
50         int i, count;
51
52         /* discard 2 header lines:
53          * "common" partiton"
54          * ------------------
55          */
56         pos = buf;
57         count = 0;
58
59         for (i = 0; i < len; i++) {
60                 if (pos[i] == '\n')
61                         count++;
62                 if (count == 2)
63                         break;
64         }
65
66         if (i == len) {
67                 fprintf(stderr, "failure parsing nvram output\n");
68                 return -1;
69         }
70
71         for (pos = buf + i; pos < buf + len; pos += paramlen + 1) {
72                 unsigned int namelen;
73                 char *newline;
74
75                 newline = strchr(pos, '\n');
76                 if (!newline)
77                         break;
78
79                 *newline = '\0';
80
81                 paramlen = strlen(pos);
82
83                 name = pos;
84                 value = strchr(pos, '=');
85                 if (!value)
86                         continue;
87
88                 namelen = value - name;
89                 if (namelen == 0)
90                         continue;
91
92                 if (!param_list_is_known_n(platform->params, name, namelen))
93                         continue;
94
95                 *value = '\0';
96                 value++;
97
98                 param_list_set(platform->params, name, value, false);
99         }
100
101         return 0;
102 }
103
104 static int parse_nvram(struct platform_powerpc *platform)
105 {
106         struct process_stdout *stdout;
107         const char *argv[5];
108         int rc;
109
110         argv[0] = "nvram";
111         argv[1] = "--print-config";
112         argv[2] = "--partition";
113         argv[3] = partition;
114         argv[4] = NULL;
115
116         rc = process_get_stdout_argv(NULL, &stdout, argv);
117
118         if (rc) {
119                 fprintf(stderr, "nvram process returned "
120                                 "non-zero exit status\n");
121                 rc = -1;
122         } else {
123                 rc = parse_nvram_params(platform, stdout->buf, stdout->len);
124         }
125
126         talloc_free(stdout);
127         return rc;
128 }
129
130 static int write_nvram(struct platform_powerpc *platform)
131 {
132         struct process *process;
133         struct param *param;
134         const char *argv[6];
135         int rc = 0;
136
137         argv[0] = "nvram";
138         argv[1] = "--update-config";
139         argv[2] = NULL;
140         argv[3] = "--partition";
141         argv[4] = partition;
142         argv[5] = NULL;
143
144         process = process_create(platform);
145         process->path = "nvram";
146         process->argv = argv;
147
148         param_list_for_each(platform->params, param) {
149                 char *paramstr;
150
151                 if (!param->modified)
152                         continue;
153
154                 paramstr = talloc_asprintf(platform, "%s=%s",
155                                 param->name, param->value);
156                 argv[2] = paramstr;
157
158                 rc = process_run_sync(process);
159
160                 talloc_free(paramstr);
161
162                 if (rc || !process_exit_ok(process)) {
163                         rc = -1;
164                         pb_log("nvram update process returned "
165                                         "non-zero exit status\n");
166                         break;
167                 }
168         }
169
170         process_release(process);
171         return rc;
172 }
173
174 static void params_update_all(struct param_list *pl,
175         const struct config *config, const struct config *defaults)
176 {
177         char *tmp = NULL;
178         const char *val;
179
180         if (config->autoboot_enabled == defaults->autoboot_enabled)
181                 val = "";
182         else
183                 val = config->autoboot_enabled ? "true" : "false";
184
185         param_list_set_non_empty(pl, "auto-boot?", val, true);
186
187         if (config->autoboot_timeout_sec == defaults->autoboot_timeout_sec)
188                 val = "";
189         else
190                 val = tmp = talloc_asprintf(pl, "%d",
191                         config->autoboot_timeout_sec);
192
193         param_list_set_non_empty(pl, "petitboot,timeout", val, true);
194         if (tmp)
195                 talloc_free(tmp);
196
197         val = config->lang ?: "";
198         param_list_set_non_empty(pl, "petitboot,language", val, true);
199
200         if (config->allow_writes == defaults->allow_writes)
201                 val = "";
202         else
203                 val = config->allow_writes ? "true" : "false";
204         param_list_set_non_empty(pl, "petitboot,write?", val, true);
205
206         if (!config->manual_console) {
207                 val = config->boot_console ?: "";
208                 param_list_set_non_empty(pl, "petitboot,console", val, true);
209         }
210
211         val = config->http_proxy ?: "";
212         param_list_set_non_empty(pl, "petitboot,http_proxy", val, true);
213         val = config->https_proxy ?: "";
214         param_list_set_non_empty(pl, "petitboot,https_proxy", val, true);
215
216         params_update_network_values(pl, "petitboot,network", config);
217         params_update_bootdev_values(pl, "petitboot,bootdevs", config);
218 }
219
220 static void config_set_ipmi_bootdev(struct config *config, enum ipmi_bootdev bootdev,
221                 bool persistent)
222 {
223         config->ipmi_bootdev = bootdev;
224         config->ipmi_bootdev_persistent = persistent;
225
226         if (bootdev == IPMI_BOOTDEV_SAFE)
227                 config->safe_mode = true;
228 }
229
230 static int read_bootdev_sysparam(const char *name, uint8_t *val)
231 {
232         uint8_t buf[2];
233         char path[50];
234         int fd, rc;
235
236         assert(strlen(sysparams_dir) + strlen(name) < sizeof(path));
237         snprintf(path, sizeof(path), "%s%s", sysparams_dir, name);
238
239         fd = open(path, O_RDONLY);
240         if (fd < 0) {
241                 pb_debug("powerpc: can't access sysparam %s\n",
242                                 name);
243                 return -1;
244         }
245
246         rc = read(fd, buf, sizeof(buf));
247
248         close(fd);
249
250         /* bootdev definitions should only be one byte in size */
251         if (rc != 1) {
252                 pb_debug("powerpc: sysparam %s read returned %d\n",
253                                 name, rc);
254                 return -1;
255         }
256
257         pb_debug("powerpc: sysparam %s: 0x%02x\n", name, buf[0]);
258
259         if (!ipmi_bootdev_is_valid(buf[0]))
260                 return -1;
261
262         *val = buf[0];
263         return 0;
264 }
265
266 static int write_bootdev_sysparam(const char *name, uint8_t val)
267 {
268         char path[50];
269         int fd, rc;
270
271         assert(strlen(sysparams_dir) + strlen(name) < sizeof(path));
272         snprintf(path, sizeof(path), "%s%s", sysparams_dir, name);
273
274         fd = open(path, O_WRONLY);
275         if (fd < 0) {
276                 pb_debug("powerpc: can't access sysparam %s for writing\n",
277                                 name);
278                 return -1;
279         }
280
281         for (;;) {
282                 errno = 0;
283                 rc = write(fd, &val, sizeof(val));
284                 if (rc == sizeof(val)) {
285                         rc = 0;
286                         break;
287                 }
288
289                 if (rc <= 0 && errno != EINTR) {
290                         pb_log("powerpc: error updating sysparam %s: %s",
291                                         name, strerror(errno));
292                         rc = -1;
293                         break;
294                 }
295         }
296
297         close(fd);
298
299         if (!rc)
300                 pb_debug("powerpc: set sysparam %s: 0x%02x\n", name, val);
301
302         return rc;
303 }
304
305 static int clear_ipmi_bootdev_sysparams(
306                 struct platform_powerpc *platform __attribute__((unused)),
307                 bool persistent)
308 {
309         if (persistent) {
310                 /* invalidate default-boot-device setting */
311                 write_bootdev_sysparam("default-boot-device", 0xff);
312         } else {
313                 /* invalidate next-boot-device setting */
314                 write_bootdev_sysparam("next-boot-device", 0xff);
315         }
316         return 0;
317 }
318
319 static int get_ipmi_bootdev_sysparams(
320                 struct platform_powerpc *platform __attribute__((unused)),
321                 uint8_t *bootdev, bool *persistent)
322 {
323         uint8_t next_bootdev, default_bootdev;
324         bool next_valid, default_valid;
325         int rc;
326
327         rc = read_bootdev_sysparam("next-boot-device", &next_bootdev);
328         next_valid = rc == 0;
329
330         rc = read_bootdev_sysparam("default-boot-device", &default_bootdev);
331         default_valid = rc == 0;
332
333         /* nothing valid? no need to change the config */
334         if (!next_valid && !default_valid)
335                 return -1;
336
337         *persistent = !next_valid;
338         *bootdev = next_valid ? next_bootdev : default_bootdev;
339         return 0;
340 }
341
342 static int clear_ipmi_bootdev_ipmi(struct platform_powerpc *platform,
343                                    bool persistent __attribute__((unused)))
344 {
345         uint16_t resp_len;
346         uint8_t resp[1];
347         uint8_t req[] = {
348                 0x05, /* parameter selector: boot flags */
349                 0x80, /* data 1: valid */
350                 0x00, /* data 2: bootdev: no override */
351                 0x00, /* data 3: system defaults */
352                 0x00, /* data 4: no request for shared mode, mux defaults */
353                 0x00, /* data 5: no instance request */
354         };
355
356         resp_len = sizeof(resp);
357
358         ipmi_transaction(platform->ipmi, IPMI_NETFN_CHASSIS,
359                         IPMI_CMD_CHASSIS_SET_SYSTEM_BOOT_OPTIONS,
360                         req, sizeof(req),
361                         resp, &resp_len,
362                         ipmi_timeout);
363         return 0;
364 }
365
366 static int get_ipmi_bootdev_ipmi(struct platform_powerpc *platform,
367                 uint8_t *bootdev, bool *persistent)
368 {
369         uint16_t resp_len;
370         uint8_t resp[8];
371         char *debug_buf;
372         int rc;
373         uint8_t req[] = {
374                 0x05, /* parameter selector: boot flags */
375                 0x00, /* no set selector */
376                 0x00, /* no block selector */
377         };
378
379         resp_len = sizeof(resp);
380         rc = ipmi_transaction(platform->ipmi, IPMI_NETFN_CHASSIS,
381                         IPMI_CMD_CHASSIS_GET_SYSTEM_BOOT_OPTIONS,
382                         req, sizeof(req),
383                         resp, &resp_len,
384                         ipmi_timeout);
385         if (rc) {
386                 pb_log("platform: error reading IPMI boot options\n");
387                 return -1;
388         }
389
390         if (resp_len != sizeof(resp)) {
391                 pb_log("platform: unexpected length (%d) in "
392                                 "boot options response\n", resp_len);
393                 return -1;
394         }
395
396         debug_buf = format_buffer(platform, resp, resp_len);
397         pb_debug_fn("IPMI get_bootdev response:\n%s\n", debug_buf);
398         talloc_free(debug_buf);
399
400         if (resp[0] != 0) {
401                 pb_log("platform: non-zero completion code %d from IPMI req\n",
402                                 resp[0]);
403                 return -1;
404         }
405
406         /* check for correct parameter version */
407         if ((resp[1] & 0xf) != 0x1) {
408                 pb_log("platform: unexpected version (0x%x) in "
409                                 "boot options response\n", resp[0]);
410                 return -1;
411         }
412
413         /* check for valid paramters */
414         if (resp[2] & 0x80) {
415                 pb_debug("platform: boot options are invalid/locked\n");
416                 return -1;
417         }
418
419         *persistent = false;
420
421         /* check for valid flags */
422         if (!(resp[3] & 0x80)) {
423                 pb_debug("platform: boot flags are invalid, ignoring\n");
424                 return -1;
425         }
426
427         *persistent = resp[3] & 0x40;
428         *bootdev = (resp[4] >> 2) & 0x0f;
429         return 0;
430 }
431
432 static int set_ipmi_os_boot_sensor(struct platform_powerpc *platform)
433 {
434         int sensor_number;
435         uint16_t resp_len;
436         uint8_t resp[1];
437         uint8_t req[] = {
438                 0x00, /* sensor number: os boot */
439                 0xA9, /* operation: set everything */
440                 0x00, /* sensor reading: none */
441                 0x40, /* assertion mask lsb: set state 6 */
442                 0x00, /* assertion mask msb: none */
443                 0x00, /* deassertion mask lsb: none */
444                 0x00, /* deassertion mask msb: none */
445                 0x00, /* event data 1: none */
446                 0x00, /* event data 2: none */
447                 0x00, /* event data 3: none */
448         };
449
450         sensor_number = get_ipmi_sensor(platform, IPMI_SENSOR_ID_OS_BOOT);
451         if (sensor_number < 0) {
452                 pb_log("Couldn't find OS boot sensor in device tree\n");
453                 return -1;
454         }
455
456         req[0] = sensor_number;
457
458         resp_len = sizeof(resp);
459
460         ipmi_transaction(platform->ipmi, IPMI_NETFN_SE,
461                         IPMI_CMD_SENSOR_SET,
462                         req, sizeof(req),
463                         resp, &resp_len,
464                         ipmi_timeout); return 0;
465
466         return 0;
467 }
468
469 static void get_ipmi_network_override(struct platform_powerpc *platform,
470                         struct config *config)
471 {
472         uint16_t min_len = 12, resp_len = 53, version;
473         const uint32_t magic_value = 0x21706221;
474         uint8_t resp[resp_len];
475         char *debug_buf;
476         uint32_t cookie;
477         bool persistent;
478         int i, rc;
479         uint8_t req[] = {
480                 0x61, /* parameter selector: OEM section (network) */
481                 0x00, /* no set selector */
482                 0x00, /* no block selector */
483         };
484
485         rc = ipmi_transaction(platform->ipmi, IPMI_NETFN_CHASSIS,
486                         IPMI_CMD_CHASSIS_GET_SYSTEM_BOOT_OPTIONS,
487                         req, sizeof(req),
488                         resp, &resp_len,
489                         ipmi_timeout);
490
491         debug_buf = format_buffer(platform, resp, resp_len);
492         pb_debug_fn("IPMI net override response:\n%s\n", debug_buf);
493         talloc_free(debug_buf);
494
495         if (rc) {
496                 pb_debug("IPMI network config option unavailable\n");
497                 return;
498         }
499
500         if (resp_len < min_len) {
501                 pb_debug("IPMI net response too small\n");
502                 return;
503         }
504
505         if (resp[0] != 0) {
506                 pb_log("platform: non-zero completion code %d from IPMI network req\n",
507                        resp[0]);
508                 return;
509         }
510
511         /* Check for correct parameter version */
512         if ((resp[1] & 0xf) != 0x1) {
513                 pb_log("platform: unexpected version (0x%x) in network override response\n",
514                        resp[0]);
515                 return;
516         }
517
518         /* Check that the parameters are valid */
519         if (resp[2] & 0x80) {
520                 pb_debug("platform: network override is invalid/locked\n");
521                 return;
522         }
523
524         /* Check for valid parameters in the boot flags section */
525         if (!(resp[3] & 0x80)) {
526                 pb_debug("platform: network override valid flag not set\n");
527                 return;
528         }
529         /* Read the persistent flag; if it is set we need to save this config */
530         persistent = resp[3] & 0x40;
531         if (persistent)
532                 pb_debug("platform: network override is persistent\n");
533
534         /* Check 4-byte cookie value */
535         i = 4;
536         memcpy(&cookie, &resp[i], sizeof(cookie));
537         cookie = __be32_to_cpu(cookie);
538         if (cookie != magic_value) {
539                 pb_log_fn("Incorrect cookie %x\n", cookie);
540                 return;
541         }
542         i += sizeof(cookie);
543
544         /* Check 2-byte version number */
545         memcpy(&version, &resp[i], sizeof(version));
546         version = __be16_to_cpu(version);
547         i += sizeof(version);
548         if (version != 1) {
549                 pb_debug("Unexpected version: %u\n", version);
550                 return;
551         }
552
553         /* Interpret the rest of the interface config */
554         rc = parse_ipmi_interface_override(config, &resp[i], resp_len - i);
555
556         if (!rc && persistent) {
557                 /* Write this new config to NVRAM */
558                 params_update_network_values(platform->params,
559                         "petitboot,network", config);
560                 rc = write_nvram(platform);
561                 if (rc)
562                         pb_log("platform: Failed to save persistent interface override\n");
563         }
564 }
565
566 static void config_get_active_consoles(struct config *config)
567 {
568         struct stat sbuf;
569         char *fsp_prop = NULL;
570
571         config->n_consoles = 2;
572         config->consoles = talloc_array(config, char *, config->n_consoles);
573         if (!config->consoles)
574                 goto err;
575
576         config->consoles[0] = talloc_asprintf(config->consoles,
577                                         "/dev/hvc0 [IPMI / Serial]");
578         config->consoles[1] = talloc_asprintf(config->consoles,
579                                         "/dev/tty1 [VGA]");
580
581         fsp_prop = talloc_asprintf(config, "%sfsps", devtree_dir);
582         if (stat(fsp_prop, &sbuf) == 0) {
583                 /* FSP based machines also have a separate serial console */
584                 config->consoles = talloc_realloc(config, config->consoles,
585                                                 char *, config->n_consoles + 1);
586                 if (!config->consoles)
587                         goto err;
588                 config->consoles[config->n_consoles++] = talloc_asprintf(
589                                                 config->consoles,
590                                                 "/dev/hvc1 [Serial]");
591         }
592
593         return;
594 err:
595         config->n_consoles = 0;
596         pb_log("Failed to allocate memory for consoles\n");
597 }
598
599 static int load_config(struct platform *p, struct config *config)
600 {
601         struct platform_powerpc *platform = to_platform_powerpc(p);
602         const char *hash;
603         int rc;
604
605         rc = parse_nvram(platform);
606         if (rc)
607                 pb_log_fn("Failed to parse nvram\n");
608
609         config_populate_all(config, platform->params);
610
611         if (platform->get_ipmi_bootdev) {
612                 bool bootdev_persistent;
613                 uint8_t bootdev = IPMI_BOOTDEV_INVALID;
614                 rc = platform->get_ipmi_bootdev(platform, &bootdev,
615                                 &bootdev_persistent);
616                 if (!rc && ipmi_bootdev_is_valid(bootdev)) {
617                         config_set_ipmi_bootdev(config, bootdev,
618                                 bootdev_persistent);
619                 }
620         }
621
622         if (platform->ipmi)
623                 get_ipmi_network_override(platform, config);
624
625         config_get_active_consoles(config);
626
627
628         hash = param_list_get_value(platform->params, "petitboot,password");
629         if (hash) {
630                 rc = crypt_set_password_hash(platform, hash);
631                 if (rc)
632                         pb_log("Failed to set password hash\n");
633         }
634
635         return 0;
636 }
637
638 static int save_config(struct platform *p, struct config *config)
639 {
640         struct platform_powerpc *platform = to_platform_powerpc(p);
641         struct config *defaults;
642
643         if (config->ipmi_bootdev == IPMI_BOOTDEV_INVALID &&
644             platform->clear_ipmi_bootdev) {
645                 platform->clear_ipmi_bootdev(platform,
646                                 config->ipmi_bootdev_persistent);
647                 config->ipmi_bootdev = IPMI_BOOTDEV_NONE;
648                 config->ipmi_bootdev_persistent = false;
649         }
650
651         defaults = talloc_zero(platform, struct config);
652         config_set_defaults(defaults);
653
654         params_update_all(platform->params, config, defaults);
655
656         talloc_free(defaults);
657         return write_nvram(platform);
658 }
659
660 static void pre_boot(struct platform *p, const struct config *config)
661 {
662         struct platform_powerpc *platform = to_platform_powerpc(p);
663
664         if (!config->ipmi_bootdev_persistent && platform->clear_ipmi_bootdev)
665                 platform->clear_ipmi_bootdev(platform, false);
666
667         if (platform->set_os_boot_sensor)
668                 platform->set_os_boot_sensor(platform);
669 }
670
671 static int get_sysinfo(struct platform *p, struct system_info *sysinfo)
672 {
673         struct platform_powerpc *platform = p->platform_data;
674         char *buf, *filename;
675         int len, rc;
676
677         filename = talloc_asprintf(platform, "%smodel", devtree_dir);
678         rc = read_file(platform, filename, &buf, &len);
679         if (rc == 0)
680                 sysinfo->type = talloc_steal(sysinfo, buf);
681         talloc_free(filename);
682
683         filename = talloc_asprintf(platform, "%ssystem-id", devtree_dir);
684         rc = read_file(platform, filename, &buf, &len);
685         if (rc == 0)
686                 sysinfo->identifier = talloc_steal(sysinfo, buf);
687         talloc_free(filename);
688
689         sysinfo->bmc_mac = talloc_zero_size(sysinfo, HWADDR_SIZE);
690
691         if (platform->ipmi) {
692                 ipmi_get_bmc_mac(platform->ipmi, sysinfo->bmc_mac);
693                 ipmi_get_bmc_versions(platform->ipmi, sysinfo);
694         }
695
696         if (platform->get_platform_versions)
697                 platform->get_platform_versions(sysinfo);
698
699         return 0;
700 }
701
702 static bool restrict_clients(struct platform *p)
703 {
704         struct platform_powerpc *platform = to_platform_powerpc(p);
705
706         return param_list_get_value(platform->params, "petitboot,password") != NULL;
707 }
708
709 static int set_password(struct platform *p, const char *hash)
710 {
711         struct platform_powerpc *platform = to_platform_powerpc(p);
712
713         param_list_set(platform->params, "petitboot,password", hash, true);
714         write_nvram(platform);
715
716         return 0;
717 }
718
719 static bool probe(struct platform *p, void *ctx)
720 {
721         struct platform_powerpc *platform;
722         struct stat statbuf;
723         bool bmc_present;
724         int rc;
725
726         /* we need a device tree */
727         rc = stat("/proc/device-tree", &statbuf);
728         if (rc)
729                 return false;
730
731         if (!S_ISDIR(statbuf.st_mode))
732                 return false;
733
734         platform = talloc_zero(ctx, struct platform_powerpc);
735         platform->params = talloc_zero(platform, struct param_list);
736         param_list_init(platform->params, common_known_params());
737
738         p->platform_data = platform;
739
740         bmc_present = stat("/proc/device-tree/bmc", &statbuf) == 0;
741
742         if (ipmi_present() && bmc_present) {
743                 pb_debug("platform: using direct IPMI for IPMI paramters\n");
744                 platform->ipmi = ipmi_open(platform);
745                 platform->get_ipmi_bootdev = get_ipmi_bootdev_ipmi;
746                 platform->clear_ipmi_bootdev = clear_ipmi_bootdev_ipmi;
747                 platform->set_os_boot_sensor = set_ipmi_os_boot_sensor;
748         } else if (!stat(sysparams_dir, &statbuf)) {
749                 pb_debug("platform: using sysparams for IPMI paramters\n");
750                 platform->get_ipmi_bootdev = get_ipmi_bootdev_sysparams;
751                 platform->clear_ipmi_bootdev = clear_ipmi_bootdev_sysparams;
752
753         } else {
754                 pb_log("platform: no IPMI parameter support\n");
755         }
756
757         if (bmc_present)
758                 platform->get_platform_versions = hostboot_load_versions;
759
760         return true;
761 }
762
763
764 static struct platform platform_powerpc = {
765         .name                   = "powerpc",
766         .dhcp_arch_id           = 0x000e,
767         .probe                  = probe,
768         .load_config            = load_config,
769         .save_config            = save_config,
770         .pre_boot               = pre_boot,
771         .get_sysinfo            = get_sysinfo,
772         .restrict_clients       = restrict_clients,
773         .set_password           = set_password,
774 };
775
776 register_platform(platform_powerpc);