Changeset 102f641 in mainline for uspace/srv/sysman


Ignore:
Timestamp:
2019-09-02T19:01:50Z (7 years ago)
Author:
Matthieu Riolo <matthieu.riolo@…>
Children:
25697163
Parents:
241f1985
Message:

Correcting syntax according to ccheck

Location:
uspace/srv/sysman
Files:
28 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/sysman/connection_broker.c

    r241f1985 r102f641  
    9696        }
    9797
    98 
    9998        retval = ENOTSUP;
    10099
    … …  
    119118        while (true) {
    120119                ipc_call_t call;
    121                
     120
    122121                if (!async_get_call(&call) || !ipc_get_imethod(&call)) {
    123122                        /* Client disconnected */
    … …  
    146145        }
    147146}
    148 
    149 

  • uspace/srv/sysman/connection_ctl.c

    r241f1985 r102f641  
    4141#include "sysman.h"
    4242
    43 
    4443// TODO possibly provide as type-safe function + macro in sysman.h for generic boxing
    4544static ipc_call_t *box_callid(ipc_call_t *icall)
    … …  
    215214        size_t act_size;
    216215        int rc;
    217        
     216
    218217        if (!async_data_read_receive(&call, &size)) {
    219218                async_answer_0(&call, EREFUSED);
    … …  
    221220                return;
    222221        }
    223        
    224        
     222
    225223        unit_handle_t *handles = malloc(size);
    226224        if (handles == NULL && size > 0) {
    … …  
    229227                return;
    230228        }
    231        
    232        
     229
    233230        rc = fill_handles_buffer(handles, size, &act_size);
    234231        if (rc != EOK) {
    … …  
    237234                return;
    238235        }
    239        
     236
    240237        size_t real_size = min(act_size, size);
    241238        sysarg_t retval = async_data_read_finalize(&call, handles, real_size);
    242239        free(handles);
    243        
     240
    244241        async_answer_1(icall, retval, act_size);
    245242}
    … …  
    249246        ipc_call_t call;
    250247        size_t size;
    251        
     248
    252249        if (!async_data_read_receive(&call, &size)) {
    253250                async_answer_0(&call, EREFUSED);
    … …  
    255252                return;
    256253        }
    257        
     254
    258255        unit_t *u = repo_find_unit_by_handle(ipc_get_arg1(icall));
    259256        if (u == NULL) {
    … …  
    262259                return;
    263260        }
    264        
     261
    265262        size_t real_size = min(str_size(u->name) + 1, size);
    266263        sysarg_t retval = async_data_read_finalize(&call, u->name, real_size);
    267        
     264
    268265        async_answer_0(icall, retval);
    269266}
    … …  
    303300        while (true) {
    304301                ipc_call_t call;
    305                
     302
    306303                if (!async_get_call(&call) || !ipc_get_imethod(&call)) {
    307304                        /* Client disconnected */
    … …  
    339336        }
    340337}
    341 

  • uspace/srv/sysman/edge.c

    r241f1985 r102f641  
    118118}
    119119
    120 
    121120/**
    122121 * @return        EOK on success

  • uspace/srv/sysman/edge.h

    r241f1985 r102f641  
    7171extern void edge_remove(unit_edge_t **);
    7272
    73 
    7473#endif
    75 
    76 

  • uspace/srv/sysman/job.c

    r241f1985 r102f641  
    3939#include "sysman.h"
    4040
    41 
    4241/*
    4342 * Static functions
    4443 */
    45 
    4644
    4745/** Remove blocking_job from blocked job structure
    … …  
    273271        sysman_raise_event(&sysman_event_job_finished, job);
    274272}
    275 

  • uspace/srv/sysman/job.h

    r241f1985 r102f641  
    6565        /** Jobs that this job is preventing from running */
    6666        dyn_array_t blocked_jobs;
    67         /** No. of jobs that the job is actually blocking (may differ from size
    68          * of blocked_jobs for not fully merged job */
     67        /**
     68         * No. of jobs that the job is actually blocking (may differ from size
     69         * of blocked_jobs for not fully merged job
     70         */
    6971        size_t blocked_jobs_count;
    7072        /** No. of jobs that must finish before this job */

  • uspace/srv/sysman/job_closure.c

    r241f1985 r102f641  
    3737#include "log.h"
    3838
    39 
    4039/** Struct describes how to traverse units graph */
    4140struct bfs_ops;
    … …  
    5251         * return result of visit (error stops further traversal)
    5352         */
    54         int (* visit)(unit_t *, unit_edge_t *, bfs_ops_t *, void *);
     53        int (*visit)(unit_t *, unit_edge_t *, bfs_ops_t *, void *);
    5554
    5655        /** Clean units remaining in BFS queue after error */
    57         void (* clean)(unit_t *, bfs_ops_t *, void *);
     56        void (*clean)(unit_t *, bfs_ops_t *, void *);
    5857};
    5958
    … …  
    6564{
    6665        assert(blocking_job->blocked_jobs.size ==
    67             blocking_job->blocked_jobs_count);
     66            blocking_job->blocked_jobs_count);
    6867
    6968        int rc = dyn_array_append(&blocking_job->blocked_jobs, job_t *,
    … …  
    203202        unit->bfs_tag = true;
    204203        list_append(&unit->bfs_link, &units_fifo);
    205        
     204
    206205        while (!list_empty(&units_fifo)) {
    207206                unit = list_get_instance(list_first(&units_fifo), unit_t,
    … …  
    209208                list_remove(&unit->bfs_link);
    210209
    211 
    212                 if (ops->direction == BFS_FORWARD)
    213                     list_foreach(unit->edges_out, edges_out, unit_edge_t, e) {
    214                         unit_t *u = e->output;
    215                         if (!u->bfs_tag) {
    216                                 u->bfs_tag = true;
    217                                 list_append(&u->bfs_link, &units_fifo);
     210                if (ops->direction == BFS_FORWARD) {
     211                        list_foreach(unit->edges_out, edges_out, unit_edge_t, e) {
     212                                unit_t *u = e->output;
     213                                if (!u->bfs_tag) {
     214                                        u->bfs_tag = true;
     215                                        list_append(&u->bfs_link, &units_fifo);
     216                                }
     217                                rc = ops->visit(u, e, ops, arg);
     218                                if (rc != EOK) {
     219                                        goto finish;
     220                                }
    218221                        }
    219                         rc = ops->visit(u, e, ops, arg);
    220                         if (rc != EOK) {
    221                                 goto finish;
    222                         }
    223                 } else
    224                     list_foreach(unit->edges_in, edges_in, unit_edge_t, e) {
    225                         unit_t *u = e->input;
    226                         if (!u->bfs_tag) {
    227                                 u->bfs_tag = true;
    228                                 list_append(&u->bfs_link, &units_fifo);
    229                         }
    230                         rc = ops->visit(u, e, ops, arg);
    231                         if (rc != EOK) {
    232                                 goto finish;
     222                } else {
     223                        list_foreach(unit->edges_in, edges_in, unit_edge_t, e) {
     224                                unit_t *u = e->input;
     225                                if (!u->bfs_tag) {
     226                                        u->bfs_tag = true;
     227                                        list_append(&u->bfs_link, &units_fifo);
     228                                }
     229                                rc = ops->visit(u, e, ops, arg);
     230                                if (rc != EOK) {
     231                                        goto finish;
     232                                }
    233233                        }
    234234                }
    … …  
    243243                list_remove(cur_link);
    244244        }
    245        
     245
    246246        return rc;
    247247}
    … …  
    349349        }
    350350
    351        
    352351        /* Clean after ourselves (BFS tag jobs) */
    353352        dyn_array_foreach(*job_closure, job_t *, job_it) {
    … …  
    360359        return rc;
    361360}
    362 

  • uspace/srv/sysman/job_queue.c

    r241f1985 r102f641  
    230230        }
    231231
    232         /* Unmerged jobs are enqueued, merged are disposed
     232        /*
     233         * Unmerged jobs are enqueued, merged are disposed
    233234         *
    234235         * TODO Ensure that jobs that block merged jobs contain the corrent job
    … …  
    242243                }
    243244
    244 
    245245                unit_t *u = job->unit;
    246246                assert(u->job == NULL);
    … …  
    274274        }
    275275}
    276 
    277 

  • uspace/srv/sysman/log.c

    r241f1985 r102f641  
    3939static log_level_t max_level = LVL_NOTE;
    4040
    41 extern void sysman_log_init(log_level_t level)
     41void sysman_log_init(log_level_t level)
    4242{
    4343        max_level = level;
    … …  
    5151        va_list args;
    5252        va_start(args, fmt);
    53        
     53
    5454        vprintf(fmt, args);
    5555        printf("\n");

  • uspace/srv/sysman/main.c

    r241f1985 r102f641  
    8383
    8484/** Build hard coded configuration */
    85 static errno_t create_entry_configuration(void) {
     85static errno_t create_entry_configuration(void)
     86{
    8687        errno_t rc;
    8788        unit_t *mnt_initrd = NULL;
    … …  
    108109        cfg_init->name           = str_dup(UNIT_CFG_INITRD);
    109110        CAST_CFG(cfg_init)->path = str_dup(INITRD_CFG_PATH);
    110        
     111
    111112        tgt_init = unit_create(UNIT_TARGET);
    112113        if (tgt_init == NULL) {
    … …  
    115116        }
    116117        tgt_init->name = str_dup(TARGET_INIT);
    117        
    118118
    119119        /*
    … …  
    160160        }
    161161        job_del_ref(&job);
    162        
     162
    163163        const char **target_name_ptr = arg;
    164164        prepare_and_run_job(target_name_ptr + 1);

  • uspace/srv/sysman/repo.c

    r241f1985 r102f641  
    107107}
    108108
    109 
    110109static hash_table_ops_t units_by_name_ht_ops = {
    111110        .hash            = &units_by_name_ht_hash,
    … …  
    133132{
    134133        sysman_log(LVL_DEBUG2, "%s(%s, %i)", __func__, name, lock);
    135         if (lock) fibril_rwlock_read_lock(&repo_lock);
     134        if (lock)
     135                fibril_rwlock_read_lock(&repo_lock);
    136136        ht_link_t *ht_link = hash_table_find(&units_by_name, (void *)name);
    137         if (lock) fibril_rwlock_read_unlock(&repo_lock);
     137        if (lock)
     138                fibril_rwlock_read_unlock(&repo_lock);
    138139
    139140        if (ht_link != NULL) {
    … …  
    177178}
    178179
    179 void repo_begin_update(void) {
     180void repo_begin_update(void)
     181{
    180182        sysman_log(LVL_DEBUG2, "%s", __func__);
    181183        fibril_rwlock_write_lock(&repo_lock);

  • uspace/srv/sysman/repo.h

    r241f1985 r102f641  
    8383
    8484#endif
    85 
    86 

  • uspace/srv/sysman/sm_task.c

    r241f1985 r102f641  
    3838#include "sm_task.h"
    3939
    40 
    4140/** Structure for boxing task event */
    4241struct sm_task_event {
    … …  
    103102        CAST_SVC(u_svc)->main_task_id = tid;
    104103        CAST_SVC(u_svc)->anonymous = true;
    105         /* exec_start is left undefined, maybe could be hinted by kernel's task
    106          * name */
     104        /*
     105         * exec_start is left undefined, maybe could be hinted by kernel's task
     106         * name
     107         */
    107108
    108109        /*
    … …  
    125126
    126127        return CAST_SVC(u_svc);
    127        
     128
    128129fail:
    129130        if (in_repo_update) {
    … …  
    177178                u_svc->unit.state = STATE_STARTING;
    178179        }
    179 
    180180
    181181        /* Simple incomplete state automaton */

  • uspace/srv/sysman/sysman.c

    r241f1985 r102f641  
    4040#include "unit.h"
    4141
    42 
    4342/* Do not expose this generally named type */
    4443typedef struct {
    … …  
    9998{
    10099        void *object = *(void **)key;
    101         return (
    102             hash_table_get_inst(item, observed_object_t, ht_link)->object ==
    103             object);
     100        return hash_table_get_inst(item, observed_object_t, ht_link)->object ==
     101            object;
    104102}
    105103
    … …  
    357355}
    358356
    359 
    360357/*
    361358 * Event handlers
    … …  
    436433        notify_observers(data);
    437434}
    438 

  • uspace/srv/sysman/sysman.h

    r241f1985 r102f641  
    5353extern errno_t sysman_run_job(unit_t *, unit_state_t, int, callback_handler_t, void *);
    5454
    55 
    5655extern void sysman_raise_event(event_handler_t, void *);
    5756extern void sysman_process_queue(void);

  • uspace/srv/sysman/test/job_closure.c

    r241f1985 r102f641  
    3838PCUT_INIT
    3939
    40        
     40PCUT_TEST_SUITE(job_closure);
     41
    4142static dyn_array_t exp_closure;
    4243static dyn_array_t act_closure;
    … …  
    107108}
    108109
    109 PCUT_TEST_SUITE(job_closure);
    110 
    111 PCUT_TEST_BEFORE {
     110PCUT_TEST_BEFORE
     111{
    112112        mock_create_units();
    113113        mock_set_units_state(STATE_STOPPED);
    … …  
    124124}
    125125
    126 PCUT_TEST_AFTER {
     126PCUT_TEST_AFTER
     127{
    127128        destroy_job_closure(&act_closure);
    128129        dyn_array_destroy(&act_closure);
    … …  
    134135}
    135136
    136 PCUT_TEST(job_closure_linear) {
     137PCUT_TEST(job_closure_linear)
     138{
    137139        unit_t *u0 = mock_units[UNIT_SERVICE][0];
    138140        unit_t *u1 = mock_units[UNIT_SERVICE][1];
    … …  
    165167}
    166168
    167 PCUT_TEST(job_closure_fork) {
     169PCUT_TEST(job_closure_fork)
     170{
    168171        unit_t *u0 = mock_units[UNIT_SERVICE][0];
    169172        unit_t *u1 = mock_units[UNIT_SERVICE][1];
    … …  
    196199}
    197200
    198 PCUT_TEST(job_closure_triangle) {
     201PCUT_TEST(job_closure_triangle)
     202{
    199203        unit_t *u0 = mock_units[UNIT_SERVICE][0];
    200204        unit_t *u1 = mock_units[UNIT_SERVICE][1];
    … …  
    230234}
    231235
    232 PCUT_TEST(job_closure_isolate_linears) {
     236PCUT_TEST(job_closure_isolate_linears)
     237{
    233238        unit_t *u0 = mock_units[UNIT_SERVICE][0];
    234239        unit_t *u1 = mock_units[UNIT_SERVICE][1];

  • uspace/srv/sysman/test/job_queue.c

    r241f1985 r102f641  
    3838PCUT_INIT
    3939
     40PCUT_TEST_SUITE(job_queue);
     41
    4042static bool initialized = false;
    4143
    … …  
    5153}
    5254
    53 PCUT_TEST_SUITE(job_queue);
    54 
    55 PCUT_TEST_BEFORE {
     55PCUT_TEST_BEFORE
     56{
    5657        mock_create_units();
    5758        mock_set_units_state(STATE_STOPPED);
    … …  
    7374}
    7475
    75 PCUT_TEST_AFTER {
     76PCUT_TEST_AFTER
     77{
    7678        mock_destroy_units();
    7779}
    7880
    79 PCUT_TEST(single_start_sync) {
     81PCUT_TEST(single_start_sync)
     82{
    8083        unit_type_vmts[UNIT_TARGET]->start = &mock_unit_vmt_start_sync;
    8184
    … …  
    9497}
    9598
    96 PCUT_TEST(single_start_async) {
     99PCUT_TEST(single_start_async)
     100{
    97101        unit_type_vmts[UNIT_TARGET]->start = &mock_unit_vmt_start_async;
    98102        unit_type_vmts[UNIT_TARGET]->exposee_created =
    … …  
    117121}
    118122
    119 PCUT_TEST(multipath_to_started_unit) {
     123PCUT_TEST(multipath_to_started_unit)
     124{
    120125        /* Setup mock behavior */
    121126        unit_type_vmts[UNIT_SERVICE]->start = &mock_unit_vmt_start_sync;
    … …  
    133138        mock_add_edge(s0, m0);
    134139        mock_add_edge(s1, m0);
    135        
     140
    136141        /* S1 requires another mount and S0 */
    137142        mock_add_edge(s1, s0);
    … …  
    152157}
    153158
    154 PCUT_TEST(merge_jobs_with_callback) {
     159PCUT_TEST(merge_jobs_with_callback)
     160{
    155161        /* Setup mock behavior */
    156162        unit_type_vmts[UNIT_SERVICE]->start = &mock_unit_vmt_start_async;
    … …  
    169175        /* Job not finished */
    170176        PCUT_ASSERT_NULL(j0);
    171 
    172177
    173178        /*
    … …  
    188193        PCUT_ASSERT_NOT_NULL(j0);
    189194        PCUT_ASSERT_NOT_NULL(j1);
    190        
     195
    191196        /*
    192197         * Jobs were, merged so both callbacks should have been called with the
    … …  
    202207}
    203208
    204 
    205209PCUT_EXPORT(job_queue);

  • uspace/srv/sysman/test/main.c

    r241f1985 r102f641  
    3434PCUT_IMPORT(job_queue);
    3535
    36 PCUT_MAIN()
     36PCUT_MAIN();

  • uspace/srv/sysman/test/mock_unit.c

    r241f1985 r102f641  
    104104        unit_notify_state(unit);
    105105}
    106 

  • uspace/srv/sysman/unit.c

    r241f1985 r102f641  
    5555
    5656static config_item_t unit_configuration[] = {
    57         {"After", &unit_parse_unit_list, 0, ""},
     57        { "After", &unit_parse_unit_list, 0, "" },
    5858        CONFIGURATION_ITEM_SENTINEL
    5959};
    6060
    61 
    6261static void unit_init(unit_t *unit, unit_type_t type)
    6362{
    … …  
    6665        size_t size = unit_type_vmts[type]->size;
    6766        memset(unit, 0, size);
    68        
     67
    6968        unit->type = type;
    7069        unit->state = STATE_STOPPED;
    … …  
    9796
    9897        UNIT_VMT(unit)->destroy(unit);
    99         /* TODO:
     98        /*
     99         * TODO:
    100100         *      edges
    101101         */
    … …  
    116116                    unit_section, unit, text_parse);
    117117        }
    118                                
     118
    119119        if (rc != EOK) {
    120120                return rc;

  • uspace/srv/sysman/unit.h

    r241f1985 r102f641  
    9999#include "unit_svc.h"
    100100
    101 #define DEFINE_CAST(NAME, TYPE, ENUM_TYPE)                                     \
    102         static inline TYPE *CAST_##NAME(unit_t *u)                             \
    103         {                                                                      \
    104                 if (u->type == ENUM_TYPE)                                      \
     101#define DEFINE_CAST(NAME, TYPE, ENUM_TYPE)                         \
     102        static inline TYPE *CAST_##NAME(unit_t *u)                     \
     103        {                                                              \
     104                if (u->type == ENUM_TYPE)                                  \
    105105                        return (TYPE *)u;                                      \
    106                 else                                                           \
     106                else                                                       \
    107107                        return NULL;                                           \
    108         }                                                                      \
     108        }
    109109
    110 DEFINE_CAST(CFG, unit_cfg_t, UNIT_CONFIGURATION)
    111 DEFINE_CAST(MNT, unit_mnt_t, UNIT_MOUNT)
    112 DEFINE_CAST(TGT, unit_tgt_t, UNIT_TARGET)
    113 DEFINE_CAST(SVC, unit_svc_t, UNIT_SERVICE)
     110DEFINE_CAST(CFG, unit_cfg_t, UNIT_CONFIGURATION);
     111DEFINE_CAST(MNT, unit_mnt_t, UNIT_MOUNT);
     112DEFINE_CAST(TGT, unit_tgt_t, UNIT_TARGET);
     113DEFINE_CAST(SVC, unit_svc_t, UNIT_SERVICE);
    114114
    115115struct unit_vmt {

  • uspace/srv/sysman/units/unit_cfg.c

    r241f1985 r102f641  
    4646
    4747static config_item_t unit_configuration[] = {
    48         {"Path", &config_parse_string, offsetof(unit_cfg_t, path), NULL},
     48        { "Path", &config_parse_string, offsetof(unit_cfg_t, path), NULL },
    4949        CONFIGURATION_ITEM_SENTINEL
    5050};
    … …  
    8181                goto finish;
    8282        }
    83        
     83
    8484        /* We parse files as part of ongoing repo transaction (locked). */
    8585        unit_t *u = repo_find_unit_by_name_unsafe(unit_name);
    … …  
    231231
    232232        errno_t rc = cfg_load_configuration(u_cfg->path);
    233        
     233
    234234        if (rc == EOK) {
    235235                unit->state = STATE_STARTED;
    … …  
    267267}
    268268
    269 DEFINE_UNIT_VMT(unit_cfg)
    270 
     269DEFINE_UNIT_VMT(unit_cfg);

  • uspace/srv/sysman/units/unit_mnt.c

    r241f1985 r102f641  
    4141
    4242static config_item_t unit_configuration[] = {
    43         {"What",      &config_parse_string, offsetof(unit_mnt_t, device),     NULL},
    44         {"Where",     &config_parse_string, offsetof(unit_mnt_t, mountpoint), NULL},
    45         {"Type",      &config_parse_string, offsetof(unit_mnt_t, type),       NULL},
    46         {"Autostart", &config_parse_bool,   offsetof(unit_mnt_t, autostart),  "true"},
    47         {"Blocking",  &config_parse_bool,   offsetof(unit_mnt_t, blocking),   "true"},
     43        { "What",      &config_parse_string, offsetof(unit_mnt_t, device),     NULL },
     44        { "Where",     &config_parse_string, offsetof(unit_mnt_t, mountpoint), NULL },
     45        { "Type",      &config_parse_string, offsetof(unit_mnt_t, type),       NULL },
     46        { "Autostart", &config_parse_bool,   offsetof(unit_mnt_t, autostart),  "true" },
     47        { "Blocking",  &config_parse_bool,   offsetof(unit_mnt_t, blocking),   "true" },
    4848        CONFIGURATION_ITEM_SENTINEL
    4949};
    … …  
    195195        assert(!u_mnt->autostart || u_mnt->blocking);
    196196
    197        
    198197        assert(unit->state == STATE_STOPPED);
    199198
    … …  
    203202        mnt_data.mountpoint = u_mnt->mountpoint;
    204203        mnt_data.device     = u_mnt->device;
    205         /* TODO use other mount parameters
     204        /*
     205         * TODO use other mount parameters
    206206         * mnt_data.options    = u_mnt->options;
    207207         * mnt_data.instance   = u_mnt->instance;
    … …  
    235235        assert(!u_mnt->autostart || u_mnt->blocking);
    236236
    237        
    238237        // note: we should never hit STATE_STARTING, since it'd mean there are
    239238        //       two jobs running at once (unless job cancellation is implemented)
    … …  
    284283}
    285284
    286 
    287 DEFINE_UNIT_VMT(unit_mnt)
    288 
     285DEFINE_UNIT_VMT(unit_mnt);

  • uspace/srv/sysman/units/unit_mnt.h

    r241f1985 r102f641  
    3939        char *device;
    4040
    41         /** Should be underlying units (FS server, device) be autostarted
    42          * (implies blocking) */
     41        /**
     42         * Should be underlying units (FS server, device) be autostarted
     43         * (implies blocking)
     44         */
    4345        bool autostart;
    4446
    … …  
    5052
    5153#endif
    52 

  • uspace/srv/sysman/units/unit_svc.c

    r241f1985 r102f641  
    4040
    4141static config_item_t unit_configuration[] = {
    42         {"ExecStart", &util_parse_command, offsetof(unit_svc_t, exec_start), NULL},
     42        { "ExecStart", &util_parse_command, offsetof(unit_svc_t, exec_start), NULL },
    4343        CONFIGURATION_ITEM_SENTINEL
    4444};
    … …  
    8282        assert(u_svc);
    8383
    84        
    8584        assert(unit->state == STATE_STOPPED);
    8685
    … …  
    117116        assert(u_svc);
    118117
    119        
    120118        // note: May change when job cancellation is possible.
    121119        assert(unit->state == STATE_STARTED);
    … …  
    133131
    134132        if (rc != EOK) {
    135                 /* Task may still be running, but be conservative about unit's
    136                  * state. */
     133                /*
     134                 * Task may still be running, but be conservative about unit's
     135                 * state.
     136                 */
    137137                unit->state = STATE_FAILED;
    138138                return rc;
    … …  
    144144}
    145145
    146 
    147146static void unit_svc_exposee_created(unit_t *unit)
    148147{
    149148        assert(CAST_SVC(unit));
    150         assert(unit->state == STATE_STOPPED || unit->state == STATE_STARTING || unit->state==STATE_STARTED);
     149        assert(unit->state == STATE_STOPPED || unit->state == STATE_STARTING || unit->state == STATE_STARTED);
    151150
    152151        /* Exposee itself doesn't represent started unit. */
    … …  
    160159}
    161160
    162 DEFINE_UNIT_VMT(unit_svc)
    163 
     161DEFINE_UNIT_VMT(unit_svc);

  • uspace/srv/sysman/units/unit_svc.h

    r241f1985 r102f641  
    5151
    5252#endif
    53 

  • uspace/srv/sysman/units/unit_tgt.c

    r241f1985 r102f641  
    8282}
    8383
    84 
    85 DEFINE_UNIT_VMT(unit_tgt)
    86 
     84DEFINE_UNIT_VMT(unit_tgt);

  • uspace/srv/sysman/util.c

    r241f1985 r102f641  
    8686        command->argv[command->argc] = NULL;
    8787
    88 
    8988        if (command->argc > MAX_COMMAND_ARGS) {
    9089                text_parse_raise_error(parse, lineno,
    … …  
    9594        }
    9695}
    97 
    9896
    9997void util_command_init(command_t *command)
Note: See TracChangeset for help on using the changeset viewer.