builtins.c revision d26135b34d4ee9d983931d64c8cb18dd2562b938 
1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <sys/types.h>
18#include <sys/stat.h>
19#include <fcntl.h>
20#include <unistd.h>
21#include <string.h>
22#include <stdio.h>
23#include <linux/kd.h>
24#include <errno.h>
25#include <sys/socket.h>
26#include <netinet/in.h>
27#include <linux/if.h>
28#include <arpa/inet.h>
29#include <stdlib.h>
30#include <sys/mount.h>
31#include <sys/resource.h>
32#include <sys/wait.h>
33#include <linux/loop.h>
34#include <cutils/partition_utils.h>
35#include <cutils/android_reboot.h>
36#include <fs_mgr.h>
37
38#include <selinux/selinux.h>
39#include <selinux/label.h>
40
41#include "init.h"
42#include "keywords.h"
43#include "property_service.h"
44#include "devices.h"
45#include "init_parser.h"
46#include "util.h"
47#include "log.h"
48
49#include <private/android_filesystem_config.h>
50
51int add_environment(const char *name, const char *value);
52
53extern int init_module(void *, unsigned long, const char *);
54
55static int write_file(const char *path, const char *value)
56{
57    int fd, ret, len;
58
59    fd = open(path, O_WRONLY|O_CREAT|O_NOFOLLOW, 0600);
60
61    if (fd < 0)
62        return -errno;
63
64    len = strlen(value);
65
66    do {
67        ret = write(fd, value, len);
68    } while (ret < 0 && errno == EINTR);
69
70    close(fd);
71    if (ret < 0) {
72        return -errno;
73    } else {
74        return 0;
75    }
76}
77
78static int _open(const char *path)
79{
80    int fd;
81
82    fd = open(path, O_RDONLY | O_NOFOLLOW);
83    if (fd < 0)
84        fd = open(path, O_WRONLY | O_NOFOLLOW);
85
86    return fd;
87}
88
89static int _chown(const char *path, unsigned int uid, unsigned int gid)
90{
91    int fd;
92    int ret;
93
94    fd = _open(path);
95    if (fd < 0) {
96        return -1;
97    }
98
99    ret = fchown(fd, uid, gid);
100    if (ret < 0) {
101        int errno_copy = errno;
102        close(fd);
103        errno = errno_copy;
104        return -1;
105    }
106
107    close(fd);
108
109    return 0;
110}
111
112static int _chmod(const char *path, mode_t mode)
113{
114    int fd;
115    int ret;
116
117    fd = _open(path);
118    if (fd < 0) {
119        return -1;
120    }
121
122    ret = fchmod(fd, mode);
123    if (ret < 0) {
124        int errno_copy = errno;
125        close(fd);
126        errno = errno_copy;
127        return -1;
128    }
129
130    close(fd);
131
132    return 0;
133}
134
135static int insmod(const char *filename, char *options)
136{
137    void *module;
138    unsigned size;
139    int ret;
140
141    module = read_file(filename, &size);
142    if (!module)
143        return -1;
144
145    ret = init_module(module, size, options);
146
147    free(module);
148
149    return ret;
150}
151
152static int setkey(struct kbentry *kbe)
153{
154    int fd, ret;
155
156    fd = open("/dev/tty0", O_RDWR | O_SYNC);
157    if (fd < 0)
158        return -1;
159
160    ret = ioctl(fd, KDSKBENT, kbe);
161
162    close(fd);
163    return ret;
164}
165
166static int __ifupdown(const char *interface, int up)
167{
168    struct ifreq ifr;
169    int s, ret;
170
171    strlcpy(ifr.ifr_name, interface, IFNAMSIZ);
172
173    s = socket(AF_INET, SOCK_DGRAM, 0);
174    if (s < 0)
175        return -1;
176
177    ret = ioctl(s, SIOCGIFFLAGS, &ifr);
178    if (ret < 0) {
179        goto done;
180    }
181
182    if (up)
183        ifr.ifr_flags |= IFF_UP;
184    else
185        ifr.ifr_flags &= ~IFF_UP;
186
187    ret = ioctl(s, SIOCSIFFLAGS, &ifr);
188
189done:
190    close(s);
191    return ret;
192}
193
194static void service_start_if_not_disabled(struct service *svc)
195{
196    if (!(svc->flags & SVC_DISABLED)) {
197        service_start(svc, NULL);
198    } else {
199        svc->flags |= SVC_DISABLED_START;
200    }
201}
202
203int do_chdir(int nargs, char **args)
204{
205    chdir(args[1]);
206    return 0;
207}
208
209int do_chroot(int nargs, char **args)
210{
211    chroot(args[1]);
212    return 0;
213}
214
215int do_class_start(int nargs, char **args)
216{
217        /* Starting a class does not start services
218         * which are explicitly disabled.  They must
219         * be started individually.
220         */
221    service_for_each_class(args[1], service_start_if_not_disabled);
222    return 0;
223}
224
225int do_class_stop(int nargs, char **args)
226{
227    service_for_each_class(args[1], service_stop);
228    return 0;
229}
230
231int do_class_reset(int nargs, char **args)
232{
233    service_for_each_class(args[1], service_reset);
234    return 0;
235}
236
237int do_domainname(int nargs, char **args)
238{
239    return write_file("/proc/sys/kernel/domainname", args[1]);
240}
241
242int do_enable(int nargs, char **args)
243{
244    struct service *svc;
245    svc = service_find_by_name(args[1]);
246    if (svc) {
247        svc->flags &= ~(SVC_DISABLED | SVC_RC_DISABLED);
248        if (svc->flags & SVC_DISABLED_START) {
249            service_start(svc, NULL);
250        }
251    } else {
252        return -1;
253    }
254    return 0;
255}
256
257int do_exec(int nargs, char **args)
258{
259    return -1;
260}
261
262int do_export(int nargs, char **args)
263{
264    return add_environment(args[1], args[2]);
265}
266
267int do_hostname(int nargs, char **args)
268{
269    return write_file("/proc/sys/kernel/hostname", args[1]);
270}
271
272int do_ifup(int nargs, char **args)
273{
274    return __ifupdown(args[1], 1);
275}
276
277
278static int do_insmod_inner(int nargs, char **args, int opt_len)
279{
280    char options[opt_len + 1];
281    int i;
282
283    options[0] = '\0';
284    if (nargs > 2) {
285        strcpy(options, args[2]);
286        for (i = 3; i < nargs; ++i) {
287            strcat(options, " ");
288            strcat(options, args[i]);
289        }
290    }
291
292    return insmod(args[1], options);
293}
294
295int do_insmod(int nargs, char **args)
296{
297    int i;
298    int size = 0;
299
300    if (nargs > 2) {
301        for (i = 2; i < nargs; ++i)
302            size += strlen(args[i]) + 1;
303    }
304
305    return do_insmod_inner(nargs, args, size);
306}
307
308int do_mkdir(int nargs, char **args)
309{
310    mode_t mode = 0755;
311    int ret;
312
313    /* mkdir <path> [mode] [owner] [group] */
314
315    if (nargs >= 3) {
316        mode = strtoul(args[2], 0, 8);
317    }
318
319    ret = make_dir(args[1], mode);
320    /* chmod in case the directory already exists */
321    if (ret == -1 && errno == EEXIST) {
322        ret = _chmod(args[1], mode);
323    }
324    if (ret == -1) {
325        return -errno;
326    }
327
328    if (nargs >= 4) {
329        uid_t uid = decode_uid(args[3]);
330        gid_t gid = -1;
331
332        if (nargs == 5) {
333            gid = decode_uid(args[4]);
334        }
335
336        if (_chown(args[1], uid, gid) < 0) {
337            return -errno;
338        }
339
340        /* chown may have cleared S_ISUID and S_ISGID, chmod again */
341        if (mode & (S_ISUID | S_ISGID)) {
342            ret = _chmod(args[1], mode);
343            if (ret == -1) {
344                return -errno;
345            }
346        }
347    }
348
349    return 0;
350}
351
352static struct {
353    const char *name;
354    unsigned flag;
355} mount_flags[] = {
356    { "noatime",    MS_NOATIME },
357    { "noexec",     MS_NOEXEC },
358    { "nosuid",     MS_NOSUID },
359    { "nodev",      MS_NODEV },
360    { "nodiratime", MS_NODIRATIME },
361    { "ro",         MS_RDONLY },
362    { "rw",         0 },
363    { "remount",    MS_REMOUNT },
364    { "bind",       MS_BIND },
365    { "rec",        MS_REC },
366    { "unbindable", MS_UNBINDABLE },
367    { "private",    MS_PRIVATE },
368    { "slave",      MS_SLAVE },
369    { "shared",     MS_SHARED },
370    { "defaults",   0 },
371    { 0,            0 },
372};
373
374#define DATA_MNT_POINT "/data"
375
376/* mount <type> <device> <path> <flags ...> <options> */
377int do_mount(int nargs, char **args)
378{
379    char tmp[64];
380    char *source, *target, *system;
381    char *options = NULL;
382    unsigned flags = 0;
383    int n, i;
384    int wait = 0;
385
386    for (n = 4; n < nargs; n++) {
387        for (i = 0; mount_flags[i].name; i++) {
388            if (!strcmp(args[n], mount_flags[i].name)) {
389                flags |= mount_flags[i].flag;
390                break;
391            }
392        }
393
394        if (!mount_flags[i].name) {
395            if (!strcmp(args[n], "wait"))
396                wait = 1;
397            /* if our last argument isn't a flag, wolf it up as an option string */
398            else if (n + 1 == nargs)
399                options = args[n];
400        }
401    }
402
403    system = args[1];
404    source = args[2];
405    target = args[3];
406
407    if (!strncmp(source, "mtd@", 4)) {
408        n = mtd_name_to_number(source + 4);
409        if (n < 0) {
410            return -1;
411        }
412
413        sprintf(tmp, "/dev/block/mtdblock%d", n);
414
415        if (wait)
416            wait_for_file(tmp, COMMAND_RETRY_TIMEOUT);
417        if (mount(tmp, target, system, flags, options) < 0) {
418            return -1;
419        }
420
421        goto exit_success;
422    } else if (!strncmp(source, "loop@", 5)) {
423        int mode, loop, fd;
424        struct loop_info info;
425
426        mode = (flags & MS_RDONLY) ? O_RDONLY : O_RDWR;
427        fd = open(source + 5, mode);
428        if (fd < 0) {
429            return -1;
430        }
431
432        for (n = 0; ; n++) {
433            sprintf(tmp, "/dev/block/loop%d", n);
434            loop = open(tmp, mode);
435            if (loop < 0) {
436                return -1;
437            }
438
439            /* if it is a blank loop device */
440            if (ioctl(loop, LOOP_GET_STATUS, &info) < 0 && errno == ENXIO) {
441                /* if it becomes our loop device */
442                if (ioctl(loop, LOOP_SET_FD, fd) >= 0) {
443                    close(fd);
444
445                    if (mount(tmp, target, system, flags, options) < 0) {
446                        ioctl(loop, LOOP_CLR_FD, 0);
447                        close(loop);
448                        return -1;
449                    }
450
451                    close(loop);
452                    goto exit_success;
453                }
454            }
455
456            close(loop);
457        }
458
459        close(fd);
460        ERROR("out of loopback devices");
461        return -1;
462    } else {
463        if (wait)
464            wait_for_file(source, COMMAND_RETRY_TIMEOUT);
465        if (mount(source, target, system, flags, options) < 0) {
466            return -1;
467        }
468
469    }
470
471exit_success:
472    return 0;
473
474}
475
476static int wipe_data_via_recovery()
477{
478    mkdir("/cache/recovery", 0700);
479    int fd = open("/cache/recovery/command", O_RDWR|O_CREAT|O_TRUNC, 0600);
480    if (fd >= 0) {
481        write(fd, "--wipe_data\n", strlen("--wipe_data\n") + 1);
482        write(fd, "--reason=wipe_data_via_recovery\n", strlen("--reason=wipe_data_via_recovery\n") + 1);
483        close(fd);
484    } else {
485        ERROR("could not open /cache/recovery/command\n");
486        return -1;
487    }
488    android_reboot(ANDROID_RB_RESTART2, 0, "recovery");
489    while (1) { pause(); }  // never reached
490}
491
492
493/*
494 * This function might request a reboot, in which case it will
495 * not return.
496 */
497int do_mount_all(int nargs, char **args)
498{
499    pid_t pid;
500    int ret = -1;
501    int child_ret = -1;
502    int status;
503    const char *prop;
504    struct fstab *fstab;
505
506    if (nargs != 2) {
507        return -1;
508    }
509
510    /*
511     * Call fs_mgr_mount_all() to mount all filesystems.  We fork(2) and
512     * do the call in the child to provide protection to the main init
513     * process if anything goes wrong (crash or memory leak), and wait for
514     * the child to finish in the parent.
515     */
516    pid = fork();
517    if (pid > 0) {
518        /* Parent.  Wait for the child to return */
519        int wp_ret = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
520        if (wp_ret < 0) {
521            /* Unexpected error code. We will continue anyway. */
522            NOTICE("waitpid failed rc=%d, errno=%d\n", wp_ret, errno);
523        }
524
525        if (WIFEXITED(status)) {
526            ret = WEXITSTATUS(status);
527        } else {
528            ret = -1;
529        }
530    } else if (pid == 0) {
531        /* child, call fs_mgr_mount_all() */
532        klog_set_level(6);  /* So we can see what fs_mgr_mount_all() does */
533        fstab = fs_mgr_read_fstab(args[1]);
534        child_ret = fs_mgr_mount_all(fstab);
535        fs_mgr_free_fstab(fstab);
536        if (child_ret == -1) {
537            ERROR("fs_mgr_mount_all returned an error\n");
538        }
539        _exit(child_ret);
540    } else {
541        /* fork failed, return an error */
542        return -1;
543    }
544
545    if (ret == FS_MGR_MNTALL_DEV_NEEDS_ENCRYPTION) {
546        property_set("vold.decrypt", "trigger_encryption");
547    } else if (ret == FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED) {
548        property_set("ro.crypto.state", "encrypted");
549        property_set("vold.decrypt", "trigger_default_encryption");
550    } else if (ret == FS_MGR_MNTALL_DEV_NOT_ENCRYPTED) {
551        property_set("ro.crypto.state", "unencrypted");
552        /* If fs_mgr determined this is an unencrypted device, then trigger
553         * that action.
554         */
555        action_for_each_trigger("nonencrypted", action_add_queue_tail);
556    } else if (ret == FS_MGR_MNTALL_DEV_NEEDS_RECOVERY) {
557        /* Setup a wipe via recovery, and reboot into recovery */
558        ERROR("fs_mgr_mount_all suggested recovery, so wiping data via recovery.\n");
559        ret = wipe_data_via_recovery();
560        /* If reboot worked, there is no return. */
561    } else if (ret > 0) {
562        ERROR("fs_mgr_mount_all returned unexpected error %d\n", ret);
563    }
564    /* else ... < 0: error */
565
566    return ret;
567}
568
569int do_swapon_all(int nargs, char **args)
570{
571    struct fstab *fstab;
572    int ret;
573
574    fstab = fs_mgr_read_fstab(args[1]);
575    ret = fs_mgr_swapon_all(fstab);
576    fs_mgr_free_fstab(fstab);
577
578    return ret;
579}
580
581int do_setcon(int nargs, char **args) {
582    if (is_selinux_enabled() <= 0)
583        return 0;
584    if (setcon(args[1]) < 0) {
585        return -errno;
586    }
587    return 0;
588}
589
590int do_setenforce(int nargs, char **args) {
591    if (is_selinux_enabled() <= 0)
592        return 0;
593    if (security_setenforce(atoi(args[1])) < 0) {
594        return -errno;
595    }
596    return 0;
597}
598
599int do_setkey(int nargs, char **args)
600{
601    struct kbentry kbe;
602    kbe.kb_table = strtoul(args[1], 0, 0);
603    kbe.kb_index = strtoul(args[2], 0, 0);
604    kbe.kb_value = strtoul(args[3], 0, 0);
605    return setkey(&kbe);
606}
607
608int do_setprop(int nargs, char **args)
609{
610    const char *name = args[1];
611    const char *value = args[2];
612    char prop_val[PROP_VALUE_MAX];
613    int ret;
614
615    ret = expand_props(prop_val, value, sizeof(prop_val));
616    if (ret) {
617        ERROR("cannot expand '%s' while assigning to '%s'\n", value, name);
618        return -EINVAL;
619    }
620    property_set(name, prop_val);
621    return 0;
622}
623
624int do_setrlimit(int nargs, char **args)
625{
626    struct rlimit limit;
627    int resource;
628    resource = atoi(args[1]);
629    limit.rlim_cur = atoi(args[2]);
630    limit.rlim_max = atoi(args[3]);
631    return setrlimit(resource, &limit);
632}
633
634int do_start(int nargs, char **args)
635{
636    struct service *svc;
637    svc = service_find_by_name(args[1]);
638    if (svc) {
639        service_start(svc, NULL);
640    }
641    return 0;
642}
643
644int do_stop(int nargs, char **args)
645{
646    struct service *svc;
647    svc = service_find_by_name(args[1]);
648    if (svc) {
649        service_stop(svc);
650    }
651    return 0;
652}
653
654int do_restart(int nargs, char **args)
655{
656    struct service *svc;
657    svc = service_find_by_name(args[1]);
658    if (svc) {
659        service_restart(svc);
660    }
661    return 0;
662}
663
664int do_powerctl(int nargs, char **args)
665{
666    char command[PROP_VALUE_MAX];
667    int res;
668    int len = 0;
669    int cmd = 0;
670    char *reboot_target;
671
672    res = expand_props(command, args[1], sizeof(command));
673    if (res) {
674        ERROR("powerctl: cannot expand '%s'\n", args[1]);
675        return -EINVAL;
676    }
677
678    if (strncmp(command, "shutdown", 8) == 0) {
679        cmd = ANDROID_RB_POWEROFF;
680        len = 8;
681    } else if (strncmp(command, "reboot", 6) == 0) {
682        cmd = ANDROID_RB_RESTART2;
683        len = 6;
684    } else {
685        ERROR("powerctl: unrecognized command '%s'\n", command);
686        return -EINVAL;
687    }
688
689    if (command[len] == ',') {
690        reboot_target = &command[len + 1];
691    } else if (command[len] == '\0') {
692        reboot_target = "";
693    } else {
694        ERROR("powerctl: unrecognized reboot target '%s'\n", &command[len]);
695        return -EINVAL;
696    }
697
698    return android_reboot(cmd, 0, reboot_target);
699}
700
701int do_trigger(int nargs, char **args)
702{
703    action_for_each_trigger(args[1], action_add_queue_tail);
704    return 0;
705}
706
707int do_symlink(int nargs, char **args)
708{
709    return symlink(args[1], args[2]);
710}
711
712int do_rm(int nargs, char **args)
713{
714    return unlink(args[1]);
715}
716
717int do_rmdir(int nargs, char **args)
718{
719    return rmdir(args[1]);
720}
721
722int do_sysclktz(int nargs, char **args)
723{
724    struct timezone tz;
725
726    if (nargs != 2)
727        return -1;
728
729    memset(&tz, 0, sizeof(tz));
730    tz.tz_minuteswest = atoi(args[1]);
731    if (settimeofday(NULL, &tz))
732        return -1;
733    return 0;
734}
735
736int do_write(int nargs, char **args)
737{
738    const char *path = args[1];
739    const char *value = args[2];
740    char prop_val[PROP_VALUE_MAX];
741    int ret;
742
743    ret = expand_props(prop_val, value, sizeof(prop_val));
744    if (ret) {
745        ERROR("cannot expand '%s' while writing to '%s'\n", value, path);
746        return -EINVAL;
747    }
748    return write_file(path, prop_val);
749}
750
751int do_copy(int nargs, char **args)
752{
753    char *buffer = NULL;
754    int rc = 0;
755    int fd1 = -1, fd2 = -1;
756    struct stat info;
757    int brtw, brtr;
758    char *p;
759
760    if (nargs != 3)
761        return -1;
762
763    if (stat(args[1], &info) < 0)
764        return -1;
765
766    if ((fd1 = open(args[1], O_RDONLY)) < 0)
767        goto out_err;
768
769    if ((fd2 = open(args[2], O_WRONLY|O_CREAT|O_TRUNC, 0660)) < 0)
770        goto out_err;
771
772    if (!(buffer = malloc(info.st_size)))
773        goto out_err;
774
775    p = buffer;
776    brtr = info.st_size;
777    while(brtr) {
778        rc = read(fd1, p, brtr);
779        if (rc < 0)
780            goto out_err;
781        if (rc == 0)
782            break;
783        p += rc;
784        brtr -= rc;
785    }
786
787    p = buffer;
788    brtw = info.st_size;
789    while(brtw) {
790        rc = write(fd2, p, brtw);
791        if (rc < 0)
792            goto out_err;
793        if (rc == 0)
794            break;
795        p += rc;
796        brtw -= rc;
797    }
798
799    rc = 0;
800    goto out;
801out_err:
802    rc = -1;
803out:
804    if (buffer)
805        free(buffer);
806    if (fd1 >= 0)
807        close(fd1);
808    if (fd2 >= 0)
809        close(fd2);
810    return rc;
811}
812
813int do_chown(int nargs, char **args) {
814    /* GID is optional. */
815    if (nargs == 3) {
816        if (_chown(args[2], decode_uid(args[1]), -1) < 0)
817            return -errno;
818    } else if (nargs == 4) {
819        if (_chown(args[3], decode_uid(args[1]), decode_uid(args[2])) < 0)
820            return -errno;
821    } else {
822        return -1;
823    }
824    return 0;
825}
826
827static mode_t get_mode(const char *s) {
828    mode_t mode = 0;
829    while (*s) {
830        if (*s >= '0' && *s <= '7') {
831            mode = (mode<<3) | (*s-'0');
832        } else {
833            return -1;
834        }
835        s++;
836    }
837    return mode;
838}
839
840int do_chmod(int nargs, char **args) {
841    mode_t mode = get_mode(args[1]);
842    if (_chmod(args[2], mode) < 0) {
843        return -errno;
844    }
845    return 0;
846}
847
848int do_restorecon(int nargs, char **args) {
849    int i;
850    int ret = 0;
851
852    for (i = 1; i < nargs; i++) {
853        if (restorecon(args[i]) < 0)
854            ret = -errno;
855    }
856    return ret;
857}
858
859int do_restorecon_recursive(int nargs, char **args) {
860    int i;
861    int ret = 0;
862
863    for (i = 1; i < nargs; i++) {
864        if (restorecon_recursive(args[i]) < 0)
865            ret = -errno;
866    }
867    return ret;
868}
869
870int do_setsebool(int nargs, char **args) {
871    const char *name = args[1];
872    const char *value = args[2];
873    SELboolean b;
874    int ret;
875
876    if (is_selinux_enabled() <= 0)
877        return 0;
878
879    b.name = name;
880    if (!strcmp(value, "1") || !strcasecmp(value, "true") || !strcasecmp(value, "on"))
881        b.value = 1;
882    else if (!strcmp(value, "0") || !strcasecmp(value, "false") || !strcasecmp(value, "off"))
883        b.value = 0;
884    else {
885        ERROR("setsebool: invalid value %s\n", value);
886        return -EINVAL;
887    }
888
889    if (security_set_boolean_list(1, &b, 0) < 0) {
890        ret = -errno;
891        ERROR("setsebool: could not set %s to %s\n", name, value);
892        return ret;
893    }
894
895    return 0;
896}
897
898int do_loglevel(int nargs, char **args) {
899    int log_level;
900    char log_level_str[PROP_VALUE_MAX] = "";
901    if (nargs != 2) {
902        ERROR("loglevel: missing argument\n");
903        return -EINVAL;
904    }
905
906    if (expand_props(log_level_str, args[1], sizeof(log_level_str))) {
907        ERROR("loglevel: cannot expand '%s'\n", args[1]);
908        return -EINVAL;
909    }
910    log_level = atoi(log_level_str);
911    if (log_level < KLOG_ERROR_LEVEL || log_level > KLOG_DEBUG_LEVEL) {
912        ERROR("loglevel: invalid log level'%d'\n", log_level);
913        return -EINVAL;
914    }
915    klog_set_level(log_level);
916    return 0;
917}
918
919int do_load_persist_props(int nargs, char **args) {
920    if (nargs == 1) {
921        load_persist_props();
922        return 0;
923    }
924    return -1;
925}
926
927int do_load_all_props(int nargs, char **args) {
928    if (nargs == 1) {
929        load_all_props();
930        return 0;
931    }
932    return -1;
933}
934
935int do_wait(int nargs, char **args)
936{
937    if (nargs == 2) {
938        return wait_for_file(args[1], COMMAND_RETRY_TIMEOUT);
939    } else if (nargs == 3) {
940        return wait_for_file(args[1], atoi(args[2]));
941    } else
942        return -1;
943}
944