/*===========================================================================*
* main
*===========================================================================*/
PUBLIC void main()
{
int r, caller, proc_nr, s;
message mess;
dprint("sb16_dsp.c: main()\n");
/* Get a DMA buffer. */
init_buffer();
while(TRUE) {
/* Wait for an incoming message */
receive(ANY, &mess);
caller = mess.m_source;
proc_nr = mess.IO_ENDPT;
if (is_notify(mess.m_type)) {
switch (_ENDPOINT_P(mess.m_source)) {
case HARDWARE:
dsp_hardware_msg();
continue; /* don't reply */
case SYSTEM:
continue; /* don't reply */
default:
r = EINVAL;
}
/* dont with this message */
goto send_reply;
}
/* Now carry out the work. */
switch(mess.m_type) {
case DEV_OPEN: r = dsp_open(); break;
case DEV_CLOSE: r = dsp_close(); break;
#ifdef DEV_IOCTL
case DEV_IOCTL: r = dsp_ioctl(&mess); break;
#endif
#ifdef DEV_READ
case DEV_READ: r = EINVAL; break; /* Not yet implemented */
case DEV_WRITE: dsp_write(&mess); continue; /* don't reply */
#endif
case DEV_STATUS: dsp_status(&mess); continue; /* don't reply */
default: r = EINVAL;
}
send_reply:
/* Finally, prepare and send the reply message. */
reply(TASK_REPLY, caller, proc_nr, r);
}
}
/*===========================================================================*
* main *
*===========================================================================*/
int main(int argc, char **argv)
{
/* This is the main routine of this service. The main loop consists of
* three major activities: getting new work, processing the work, and
* sending the reply. The loop never terminates, unless a panic occurs.
*/
int result;
/* SEF local startup. */
env_setargs(argc, argv);
sef_local_startup();
/* Main loop - get work and do it, forever. */
while (TRUE) {
/* Wait for incoming message, sets 'callnr' and 'who'. */
get_work();
if (is_notify(callnr)) {
switch (_ENDPOINT_P(who_e)) {
case TTY_PROC_NR:
result = do_fkey_pressed(&m_in);
break;
default:
/* FIXME: error message. */
result = EDONTREPLY;
break;
}
}
else {
printf("IS: warning, got illegal request %d from %d\n",
callnr, m_in.m_source);
result = EDONTREPLY;
}
/* Finally send reply message, unless disabled. */
if (result != EDONTREPLY) {
reply(who_e, result);
}
}
return(OK); /* shouldn't come here */
}
/*============================================================================*
* log_other *
*============================================================================*/
PRIVATE int log_other(message *m_ptr)
{
int r;
/* This function gets messages that the generic driver doesn't
* understand.
*/
if (is_notify(m_ptr->m_type)) {
return EINVAL;
}
switch(m_ptr->m_type) {
case DEV_STATUS: {
printf("log_other: unexpected DEV_STATUS request\n");
r = EDONTREPLY;
break;
}
default:
r = EINVAL;
break;
}
return r;
}
/*===========================================================================*
* main *
*===========================================================================*/
PUBLIC int main(int argc, char **argv)
{
/* This is the main routine of this service. The main loop consists of
* three major activities: getting new work, processing the work, and
* sending the reply. The loop never terminates, unless a panic occurs.
*/
message m;
int result;
/* SEF local startup. */
env_setargs(argc, argv);
sef_local_startup();
/* Main loop - get work and do it, forever. */
while (TRUE) {
/* Wait for incoming message, sets 'callnr' and 'who'. */
get_work(&m);
if (is_notify(callnr)) {
printf("DS: warning, got illegal notify from: %d\n", m.m_source);
result = EINVAL;
goto send_reply;
}
switch (callnr) {
case DS_PUBLISH:
result = do_publish(&m);
break;
case DS_RETRIEVE:
result = do_retrieve(&m);
break;
case DS_RETRIEVE_LABEL:
result = do_retrieve_label(&m);
break;
case DS_DELETE:
result = do_delete(&m);
break;
case DS_SUBSCRIBE:
result = do_subscribe(&m);
break;
case DS_CHECK:
result = do_check(&m);
break;
case DS_SNAPSHOT:
result = do_snapshot(&m);
break;
case GETSYSINFO:
result = do_getsysinfo(&m);
break;
default:
printf("DS: warning, got illegal request from %d\n", m.m_source);
result = EINVAL;
}
send_reply:
/* Finally send reply message, unless disabled. */
if (result != EDONTREPLY) {
m.m_type = result; /* build reply message */
reply(who_e, &m); /* send it away */
}
}
return(OK); /* shouldn't come here */
}
/*===========================================================================*
* main *
*===========================================================================*/
int main(void)
{
/* This is the main program of the file system. The main loop consists of
* three major activities: getting new work, processing the work, and sending
* the reply. This loop never terminates as long as the file system runs.
*/
int transid;
struct job *job;
/* SEF local startup. */
sef_local_startup();
printf("Started VFS: %d worker thread(s)\n", NR_WTHREADS);
/* This is the main loop that gets work, processes it, and sends replies. */
while (TRUE) {
yield_all(); /* let other threads run */
self = NULL;
job = NULL;
send_work();
get_work();
transid = TRNS_GET_ID(m_in.m_type);
if (IS_VFS_FS_TRANSID(transid)) {
job = worker_getjob( (thread_t) transid - VFS_TRANSID);
if (job == NULL) {
printf("VFS: spurious message %d from endpoint %d\n",
m_in.m_type, m_in.m_source);
continue;
}
m_in.m_type = TRNS_DEL_ID(m_in.m_type);
}
if (job != NULL) {
do_fs_reply(job);
continue;
} else if (who_e == PM_PROC_NR) { /* Calls from PM */
/* Special control messages from PM */
sys_worker_start(do_pm);
continue;
} else if (is_notify(call_nr)) {
/* A task notify()ed us */
sys_worker_start(do_control_msgs);
continue;
} else if (who_p < 0) { /* i.e., message comes from a task */
/* We're going to ignore this message. Tasks should
* send notify()s only.
*/
printf("VFS: ignoring message from %d (%d)\n", who_e, call_nr);
continue;
}
/* At this point we either have results from an asynchronous device
* or a new system call. In both cases a new worker thread has to be
* started and there might not be one available from the pool. This is
* not a problem (requests/replies are simply queued), except when
* they're from an FS endpoint, because these can cause a deadlock.
* handle_work() takes care of the details. */
if (IS_DEV_RS(call_nr)) {
/* We've got results for a device request */
handle_work(do_async_dev_result);
continue;
} else {
/* Normal syscall. */
handle_work(do_work);
}
}
return(OK); /* shouldn't come here */
}
void main(void)
{
mq_t *mq;
int r;
int source, m_type, timerand, fd;
u32_t tasknr;
struct fssignon device;
u8_t randbits[32];
struct timeval tv;
#if DEBUG
printk("Starting inet...\n");
printk("%s\n", version);
#endif
#if HZ_DYNAMIC
system_hz = sys_hz();
#endif
/* Read configuration. */
nw_conf();
/* Get a random number */
timerand= 1;
fd= open(RANDOM_DEV_NAME, O_RDONLY | O_NONBLOCK);
if (fd != -1)
{
r= read(fd, randbits, sizeof(randbits));
if (r == sizeof(randbits))
timerand= 0;
else
{
printk("inet: unable to read random data from %s: %s\n",
RANDOM_DEV_NAME, r == -1 ? strerror(errno) :
r == 0 ? "EOF" : "not enough data");
}
close(fd);
}
else
{
printk("inet: unable to open random device %s: %s\n",
RANDOM_DEV_NAME, strerror(errno));
}
if (timerand)
{
printk("inet: using current time for random-number seed\n");
r= gettimeofday(&tv, NULL);
if (r == -1)
{
printk("sysutime failed: %s\n", strerror(errno));
exit(1);
}
memcpy(randbits, &tv, sizeof(tv));
}
init_rand256(randbits);
/* Our new identity as a server. */
r= ds_retrieve_u32("inet", &tasknr);
if (r != 0)
ip_panic(("inet: ds_retrieve_u32 failed for 'inet': %d", r));
this_proc= tasknr;
/* Register the device group. */
device.dev= ip_dev;
device.style= STYLE_CLONE;
if (svrctl(FSSIGNON, (void *) &device) == -1) {
printk("inet: error %d on registering ethernet devices\n",
errno);
pause();
}
#ifdef BUF_CONSISTENCY_CHECK
inet_buf_debug= (getenv("inetbufdebug") &&
(strcmp(getenv("inetbufdebug"), "on") == 0));
inet_buf_debug= 100;
if (inet_buf_debug)
{
ip_warning(( "buffer consistency check enabled" ));
}
#endif
if (getenv("killerinet"))
{
ip_warning(( "killer inet active" ));
killer_inet= 1;
}
nw_init();
while (TRUE)
{
#ifdef BUF_CONSISTENCY_CHECK
if (inet_buf_debug)
{
static int buf_debug_count= 0;
if (++buf_debug_count >= inet_buf_debug)
{
buf_debug_count= 0;
if (!bf_consistency_check())
break;
}
}
#endif
if (ev_head)
{
ev_process();
continue;
}
if (clck_call_expire)
{
clck_expire_timers();
continue;
}
mq= mq_get();
if (!mq)
ip_panic(("out of messages"));
r = kipc_module_call(KIPC_RECEIVE, 0, ENDPT_ANY, &mq->mq_mess);
if (r<0)
{
ip_panic(("unable to receive: %d", r));
}
reset_time();
source= mq->mq_mess.m_source;
m_type= mq->mq_mess.m_type;
if (source == VFS_PROC_NR) {
sr_rec(mq);
} else if (is_notify(m_type)) {
if (_ENDPOINT_P(source) == CLOCK) {
clck_tick(&mq->mq_mess);
mq_free(mq);
} else if (_ENDPOINT_P(source) == PM_PROC_NR) {
/* signaled */
/* probably SIGTERM */
mq_free(mq);
} else {
/* A driver is (re)started. */
eth_check_drivers(&mq->mq_mess);
mq_free(mq);
}
} else if (m_type == DL_CONF_REPLY || m_type == DL_TASK_REPLY ||
m_type == DL_NAME_REPLY || m_type == DL_STAT_REPLY) {
eth_rec(&mq->mq_mess);
mq_free(mq);
} else {
printk("inet: got bad message type 0x%x from %d\n",
mq->mq_mess.m_type, mq->mq_mess.m_source);
mq_free(mq);
}
}
ip_panic(("task is not allowed to terminate"));
}
/*===========================================================================*
* main *
*===========================================================================*/
PUBLIC int main(void)
{
/* This is the main program of the file system. The main loop consists of
* three major activities: getting new work, processing the work, and sending
* the reply. This loop never terminates as long as the file system runs.
*/
int error;
/* SEF local startup. */
sef_local_startup();
/* This is the main loop that gets work, processes it, and sends replies. */
while (TRUE) {
SANITYCHECK;
get_work(); /* sets who and call_nr */
if (call_nr == DEV_REVIVE)
{
endpoint_t endpt;
endpt = m_in.REP_ENDPT;
if(endpt == VFS_PROC_NR) {
endpt = suspended_ep(m_in.m_source, m_in.REP_IO_GRANT);
if(endpt == NONE) {
printf("FS: proc with "
"grant %d from %d not found (revive)\n",
m_in.REP_IO_GRANT, m_in.m_source);
continue;
}
}
revive(endpt, m_in.REP_STATUS);
continue;
}
if (call_nr == DEV_REOPEN_REPL)
{
reopen_reply();
continue;
}
if (call_nr == DEV_CLOSE_REPL)
{
close_reply();
continue;
}
if (call_nr == DEV_SEL_REPL1)
{
select_reply1();
continue;
}
if (call_nr == DEV_SEL_REPL2)
{
select_reply2();
continue;
}
/* Check for special control messages first. */
if (is_notify(call_nr)) {
if (who_e == CLOCK)
{
/* Alarm timer expired. Used only for select().
* Check it.
*/
expire_timers(m_in.NOTIFY_TIMESTAMP);
}
else if(who_e == DS_PROC_NR)
{
/* DS notifies us of an event. */
ds_event();
}
else
{
/* Device notifies us of an event. */
dev_status(&m_in);
}
SANITYCHECK;
continue;
}
/* We only expect notify()s from tasks. */
if(who_p < 0) {
printf("FS: ignoring message from %d (%d)\n",
who_e, m_in.m_type);
continue;
}
/* Now it's safe to set and check fp. */
fp = &fproc[who_p]; /* pointer to proc table struct */
super_user = (fp->fp_effuid == SU_UID ? TRUE : FALSE); /* su? */
#if DO_SANITYCHECKS
if(fp_is_blocked(fp)) {
printf("VFS: requester %d call %d: suspended\n",
who_e, call_nr);
panic("requester suspended");
}
#endif
/* Calls from PM. */
if (who_e == PM_PROC_NR) {
service_pm();
continue;
}
SANITYCHECK;
/* Other calls. */
switch(call_nr)
{
case MAPDRIVER:
error= do_mapdriver();
if (error != SUSPEND) reply(who_e, error);
break;
default:
/* Call the internal function that does the work. */
if (call_nr < 0 || call_nr >= NCALLS) {
error = SUSPEND;
/* Not supposed to happen. */
printf("VFS: illegal %d system call by %d\n",
call_nr, who_e);
} else if (fp->fp_pid == PID_FREE) {
error = ENOSYS;
printf(
"FS, bad process, who = %d, call_nr = %d, endpt1 = %d\n",
who_e, call_nr, m_in.endpt1);
} else {
#if ENABLE_SYSCALL_STATS
calls_stats[call_nr]++;
#endif
SANITYCHECK;
error = (*call_vec[call_nr])();
SANITYCHECK;
}
/* Copy the results back to the user and send reply. */
if (error != SUSPEND) { reply(who_e, error); }
}
SANITYCHECK;
}
return(OK); /* shouldn't come here */
}
/*===========================================================================*
* main *
*===========================================================================*/
int main(int argc, char **argv)
{
/* This is the main routine of this service. The main loop consists of
* three major activities: getting new work, processing the work, and
* sending the reply. The loop never terminates, unless a panic occurs.
*/
message m_in;
int result;
sef_startup();
vector_init(&sem_list);
Qvector_init(&waiting_list);
stackInit(&sem_stack,5);
/* Main loop - get work and do it, forever. */
while (TRUE) {
/* Wait for incoming message, sets 'callnr' and 'who'. */
get_work(&m_in);
//printf("SEM recieved message %d\n",callnr);
if (is_notify(callnr)) {
printf("SEM: warning, got illegal notify from: %d\n", m_in.m_source);
result = EINVAL;
goto send_reply;
}
int arg = m_in.m1_i1;
switch(callnr)
{
case SEM_INIT:
//printf("Sem_init called, semaphore size 3%d.\n",arg);
result = sem_init(arg);
break;
case SEM_UP:
//printf("Sem_up called on semaphore %d.\n",arg);
result = sem_up(arg);
break;
case SEM_DOWN:
//printf("Sem_down called on semaphore %d. source: %d\n",arg,who_e);
result = sem_down(arg,m_in.m_source);
break;
case SEM_RELEASE:
//printf("Sem_release called on semaphore %d.\n",arg);
result = sem_release(arg);
break;
default:
printf("SEMAPHORE: warning, got illegal request from %d\n", m_in.m_source);
result = EINVAL;
}
send_reply:
/* Finally send reply message, unless disabled. */
if (result != EDONTREPLY) {
m_in.m_type = result; /* build reply message */
reply(who_e, &m_in); /* send it away */
}
}
Qvector_free(&waiting_list);
vector_free(&sem_list);
return(OK); /* shouldn't come here */
}
/*===========================================================================*
* main *
*===========================================================================*/
PUBLIC int main(void)
{
/* This is the main routine of this service. The main loop consists of
* three major activities: getting new work, processing the work, and
* sending the reply. The loop never terminates, unless a panic occurs.
*/
message m; /* request message */
int call_nr, who_e,who_p; /* call number and caller */
int result; /* result to return */
/* SEF local startup. */
sef_local_startup();
/* Main loop - get work and do it, forever. */
while (TRUE) {
/* Wait for request message. */
get_work(&m);
who_e = m.m_source;
who_p = _ENDPOINT_P(who_e);
if(who_p < -NR_TASKS || who_p >= NR_PROCS)
panic("RS","message from bogus source", who_e);
call_nr = m.m_type;
/* Now determine what to do. Four types of requests are expected:
* - Heartbeat messages (notifications from registered system services)
* - System notifications (POSIX signals or synchronous alarm)
* - User requests (control messages to manage system services)
* - Ready messages (reply messages from registered services)
*/
/* Notification messages are control messages and do not need a reply.
* These include heartbeat messages and system notifications.
*/
if (is_notify(m.m_type)) {
switch (who_p) {
case CLOCK:
do_period(&m); /* check services status */
continue;
case PM_PROC_NR: /* signal or PM heartbeat */
sig_handler();
default: /* heartbeat notification */
if (rproc_ptr[who_p] != NULL) { /* mark heartbeat time */
rproc_ptr[who_p]->r_alive_tm = m.NOTIFY_TIMESTAMP;
} else {
printf("Warning, RS got unexpected notify message from %d\n",
m.m_source);
}
}
}
/* If we get this far, this is a normal request.
* Handle the request and send a reply to the caller.
*/
else {
if (call_nr != GETSYSINFO &&
(call_nr < RS_RQ_BASE || call_nr >= RS_RQ_BASE+0x100))
{
/* Ignore invalid requests. Do not try to reply. */
printf("RS: got invalid request %d from endpoint %d\n",
call_nr, m.m_source);
continue;
}
/* Handler functions are responsible for permission checking. */
switch(call_nr) {
/* User requests. */
case RS_UP: result = do_up(&m); break;
case RS_DOWN: result = do_down(&m); break;
case RS_REFRESH: result = do_refresh(&m); break;
case RS_RESTART: result = do_restart(&m); break;
case RS_SHUTDOWN: result = do_shutdown(&m); break;
case RS_UPDATE: result = do_update(&m); break;
case GETSYSINFO: result = do_getsysinfo(&m); break;
case RS_LOOKUP: result = do_lookup(&m); break;
/* Ready messages. */
case RS_INIT: result = do_init_ready(&m); break;
case RS_LU_PREPARE: result = do_upd_ready(&m); break;
default:
printf("Warning, RS got unexpected request %d from %d\n",
m.m_type, m.m_source);
result = EINVAL;
}
/* Finally send reply message, unless disabled. */
if (result != EDONTREPLY) {
m.m_type = result;
reply(who_e, &m);
}
}
}
}
bool binspector_parser_t::is_unnamed_statement()
{
return is_notify() || is_summary() || is_die();
}
/*===========================================================================*
* main *
*===========================================================================*/
int main(void)
{
/* This is the main program of the file system. The main loop consists of
* three major activities: getting new work, processing the work, and sending
* the reply. This loop never terminates as long as the file system runs.
*/
int transid;
struct worker_thread *wp;
/* SEF local startup. */
sef_local_startup();
printf("Started VFS: %d worker thread(s)\n", NR_WTHREADS);
/* This is the main loop that gets work, processes it, and sends replies. */
while (TRUE) {
worker_yield(); /* let other threads run */
send_work();
/* The get_work() function returns TRUE if we have a new message to
* process. It returns FALSE if it spawned other thread activities.
*/
if (!get_work())
continue;
transid = TRNS_GET_ID(m_in.m_type);
if (IS_VFS_FS_TRANSID(transid)) {
wp = worker_get((thread_t) transid - VFS_TRANSID);
if (wp == NULL || wp->w_fp == NULL) {
printf("VFS: spurious message %d from endpoint %d\n",
m_in.m_type, m_in.m_source);
continue;
}
m_in.m_type = TRNS_DEL_ID(m_in.m_type);
do_reply(wp);
continue;
} else if (who_e == PM_PROC_NR) { /* Calls from PM */
/* Special control messages from PM */
service_pm();
continue;
} else if (is_notify(call_nr)) {
/* A task ipc_notify()ed us */
switch (who_e) {
case DS_PROC_NR:
/* Start a thread to handle DS events, if no thread
* is pending or active for it already. DS is not
* supposed to issue calls to VFS or be the subject of
* postponed PM requests, so this should be no problem.
*/
if (worker_can_start(fp))
handle_work(ds_event);
break;
case KERNEL:
mthread_stacktraces();
break;
case CLOCK:
/* Timer expired. Used only for select(). Check it. */
expire_timers(m_in.m_notify.timestamp);
break;
default:
printf("VFS: ignoring notification from %d\n", who_e);
}
continue;
} else if (who_p < 0) { /* i.e., message comes from a task */
/* We're going to ignore this message. Tasks should
* send ipc_notify()s only.
*/
printf("VFS: ignoring message from %d (%d)\n", who_e, call_nr);
continue;
}
if (IS_BDEV_RS(call_nr)) {
/* We've got results for a block device request. */
bdev_reply();
} else if (IS_CDEV_RS(call_nr)) {
/* We've got results for a character device request. */
cdev_reply();
} else {
/* Normal syscall. This spawns a new thread. */
handle_work(do_work);
}
}
return(OK); /* shouldn't come here */
}
static void dispatcher_thread(void *unused) {
/*
* Gets all messages and dispatches them.
*
* NOTE: this thread runs only when no other ddekit is
* ready. So please take care that youre threads
* leave some time for the others!
*/
message m;
int r;
int i;
int ipc_status;
_ddekit_thread_set_myprio(0);
for( ; ; ) {
/* Trigger a timer interrupt at each loop iteration */
_ddekit_timer_update();
/* Wait for messages */
if ((r = sef_receive_status(ANY, &m, &ipc_status)) != 0) {
ddekit_panic("ddekit", "sef_receive failed", r);
}
_ddekit_timer_interrupt();
_ddekit_thread_wakeup_sleeping();
if (is_notify(m.m_type)) {
switch (_ENDPOINT_P(m.m_source)) {
case HARDWARE:
for (i =0 ; i < 32 ; i++)
{
if(m.NOTIFY_ARG & (1 << i))
{
_ddekit_interrupt_trigger(i);
}
}
break;
case CLOCK:
_ddekit_timer_pending = 0;
break;
default:
ddekit_thread_schedule();
}
} else {
/*
* I don't know how to handle this msg,
* but maybe we have a msg queue which can
* handle this msg.
*/
ddekit_minix_queue_msg(&m, ipc_status);
}
}
}
int main(int argc, char **argv)
{
IsApplication *application;
GSettings *settings;
IsManager *manager;
gchar *plugin_dir;
PeasEngine *engine;
PeasExtensionSet *set;
GError *error = NULL;
gtk_init(&argc, &argv);
if (!g_irepository_require(g_irepository_get_default(), "Peas", "1.0",
0, &error))
{
is_warning("main", "Could not load Peas repository: %s", error->message);
g_error_free (error);
error = NULL;
}
engine = peas_engine_get_default();
g_signal_connect(engine, "notify::plugin-list",
G_CALLBACK(on_plugin_list_notify), NULL);
/* add home dir to search path */
plugin_dir = g_build_filename(g_get_user_config_dir(), PACKAGE,
"plugins", NULL);
peas_engine_add_search_path(engine, plugin_dir, NULL);
g_free(plugin_dir);
/* add system path to search path */
plugin_dir = g_build_filename(LIBDIR, PACKAGE, "plugins", NULL);
peas_engine_add_search_path(engine, plugin_dir, NULL);
g_free(plugin_dir);
/* init notifications */
is_notify_init();
application = is_application_new();
settings = g_settings_new("indicator-sensors.application");
g_settings_bind(settings, "temperature-scale",
application, "temperature-scale",
G_SETTINGS_BIND_DEFAULT);
/* create extension set and set manager as object */
set = peas_extension_set_new(engine, PEAS_TYPE_ACTIVATABLE,
"object", application, NULL);
/* activate all activatable extensions */
peas_extension_set_call(set, "activate");
/* and make sure to activate any ones which are found in the future */
g_signal_connect(set, "extension-added",
G_CALLBACK(on_extension_added), application);
g_signal_connect(set, "extension-removed",
G_CALLBACK(on_extension_removed), application);
/* since all plugins are now inited show a notification if we detected
* sensors but none are enabled - TODO: perhaps just open the pref's
* dialog?? */
manager = is_application_get_manager(application);
GSList *sensors = is_manager_get_all_sensors_list(manager);
if (sensors) {
gchar **enabled_sensors = is_manager_get_enabled_sensors(manager);
if (!g_strv_length(enabled_sensors)) {
is_notify(IS_NOTIFY_LEVEL_INFO,
_("No Sensors Enabled For Monitoring"),
_("Sensors detected but none are enabled for monitoring. To enable monitoring of sensors open the Preferences window and select the sensors to monitor"));
}
g_strfreev(enabled_sensors);
g_slist_foreach(sensors, (GFunc)g_object_unref, NULL);
g_slist_free(sensors);
}
gtk_main();
g_object_unref(application);
is_notify_uninit();
return 0;
}
