src/proc/proc-handler.c

   1 /*
   2  * deviced
   3  *
   4  * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the License);
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19
  20 #include <stdio.h>
  21 #include <stdbool.h>
  22 #include <unistd.h>
  23 #include <dirent.h>
  24 #include <sys/types.h>
  25 #include <device-node.h>
  26 #include <sys/un.h>
  27 #include <stdarg.h>
  28 #include <errno.h>
  29 #include <vconf.h>
  30 #include <vconf-keys.h>
  31 #include <fcntl.h>
  32
  33 #include "core/data.h"
  34 #include "core/queue.h"
  35 #include "core/log.h"
  36 #include "core/common.h"
  37 #include "core/devices.h"
  38 #include "core/device-notifier.h"
  39 #include "display/enhance.h"
  40 #include "proc-handler.h"
  41 #include "core/edbus-handler.h"
  42
  43 #define LIMITED_PROCESS_OOMADJ 15
  44
  45 #define PROCESS_VIP             "process_vip"
  46 #define PROCESS_PERMANENT       "process_permanent"
  47 #define OOMADJ_SET                      "oomadj_set"
  48
  49 #define PREDEF_BACKGRD                  "backgrd"
  50 #define PREDEF_FOREGRD                  "foregrd"
  51 #define PREDEF_ACTIVE                   "active"
  52 #define PREDEF_INACTIVE                 "inactive"
  53 #define PROCESS_GROUP_SET               "process_group_set"
  54
  55 #define VCONFKEY_INTERNAL_PRIVATE_SIOP_DISABLE  "memory/private/sysman/siop_disable"
  56
  57 #define BUFF_MAX        255
  58 #define SIOP_CTRL_LEVEL_MASK    0xFFFF
  59 #define SIOP_CTRL_LEVEL(val)    ((val & SIOP_CTRL_LEVEL_MASK) << 16)
  60 #define SIOP_CTRL_VALUE(s, r)   (s | (r << 4))
  61 #define SIOP_VALUE(d, val)      ((d) * (val & 0xF))
  62 #define REAR_VALUE(val) (val >> 4)
  63
  64 #define SIGNAL_SIOP_CHANGED     "ChangedSiop"
  65 #define SIGNAL_REAR_CHANGED     "ChangedRear"
  66 #define SIOP_LEVEL_GET          "GetSiopLevel"
  67 #define REAR_LEVEL_GET          "GetRearLevel"
  68 #define SIOP_LEVEL_SET          "SetSiopLevel"
  69
  70 #define SIGNAL_NAME_OOMADJ_SET  "OomadjSet"
  71
  72 enum SIOP_DOMAIN_TYPE {
  73         SIOP_NEGATIVE = -1,
  74         SIOP_POSITIVE = 1,
  75 };
  76
  77 static int siop = 0;
  78 static int mode = 0;
  79 static int siop_domain = SIOP_POSITIVE;
  80
  81 enum siop_scenario {
  82         MODE_NONE = 0,
  83         MODE_LCD = 1,
  84 };
  85 #ifdef NOUSE
  86 typedef struct _node {
  87         pid_t pid;
  88         struct _node *next;
  89 } Node;
  90
  91 static Node *head = NULL;
  92
  93 static Node *find_node(pid_t pid)
  94 {
  95         Node *t = head;
  96
  97         while (t != NULL) {
  98                 if (t->pid == pid)
  99                         break;
 100                 t = t->next;
 101         }
 102         return t;
 103 }
 104
 105 static Node *add_node(pid_t pid)
 106 {
 107         Node *n;
 108
 109         n = (Node *) malloc(sizeof(Node));
 110         if (n == NULL) {
 111                 _E("Not enough memory, add cond. fail");
 112                 return NULL;
 113         }
 114
 115         n->pid = pid;
 116         n->next = head;
 117         head = n;
 118
 119         return n;
 120 }
 121
 122 static int del_node(Node *n)
 123 {
 124         Node *t;
 125         Node *prev;
 126
 127         if (n == NULL)
 128                 return 0;
 129
 130         t = head;
 131         prev = NULL;
 132         while (t != NULL) {
 133                 if (t == n) {
 134                         if (prev != NULL)
 135                                 prev->next = t->next;
 136                         else
 137                                 head = head->next;
 138                         free(t);
 139                         break;
 140                 }
 141                 prev = t;
 142                 t = t->next;
 143         }
 144         return 0;
 145 }
 146 #endif
 147
 148 int cur_siop_level(void)
 149 {
 150         return  SIOP_VALUE(siop_domain, siop);
 151 }
 152
 153 static void siop_level_action(int level)
 154 {
 155         int val = SIOP_CTRL_LEVEL(level);
 156         static int old;
 157         static int siop_level = 0;
 158         static int rear_level = 0;
 159         static int initialized = 0;
 160         static int domain = 0;
 161         char *arr[1];
 162         char str_level[32];
 163
 164         if (initialized && siop == level && mode == old && domain == siop_domain)
 165                 return;
 166         initialized = 1;
 167         siop = level;
 168         domain = siop_domain;
 169         if (siop_domain == SIOP_NEGATIVE)
 170                 val = 0;
 171         old = mode;
 172         val |= old;
 173
 174         device_set_property(DEVICE_TYPE_POWER, PROP_POWER_SIOP_CONTROL, val);
 175
 176         val = SIOP_VALUE(siop_domain, level);
 177         if (siop_level != val) {
 178                 siop_level = val;
 179                 snprintf(str_level, sizeof(str_level), "%d", siop_level);
 180                 arr[0] = str_level;
 181                 _I("broadcast siop %s", str_level);
 182                 broadcast_edbus_signal(DEVICED_PATH_PROCESS, DEVICED_INTERFACE_PROCESS,
 183                         SIGNAL_SIOP_CHANGED, "i", arr);
 184         }
 185
 186         val = REAR_VALUE(level);
 187         if (rear_level != val) {
 188                 rear_level = val;
 189                 snprintf(str_level, sizeof(str_level), "%d", rear_level);
 190                 arr[0] = str_level;
 191                 _I("broadcast rear %s", str_level);
 192                 broadcast_edbus_signal(DEVICED_PATH_PROCESS, DEVICED_INTERFACE_PROCESS,
 193                         SIGNAL_REAR_CHANGED, "i", arr);
 194         }
 195         _I("level is d:%d(0x%x) s:%d r:%d", siop_domain, siop, siop_level, rear_level);
 196 }
 197
 198 static int siop_changed(int argc, char **argv)
 199 {
 200 #ifdef MICRO_DD
 201         return 0;
 202 #else
 203         int siop_level = 0;
 204         int rear_level = 0;
 205         int level;
 206         int siop_disable;
 207         int ret;
 208
 209         if (argc != 2 || argv[0] == NULL) {
 210                 _E("fail to check value");
 211                 return -1;
 212         }
 213
 214         if (argv[0] == NULL)
 215                 goto out;
 216
 217         level = atoi(argv[0]);
 218         device_set_property(DEVICE_TYPE_DISPLAY, PROP_DISPLAY_ELVSS_CONTROL, level);
 219         ret = device_get_property(DEVICE_TYPE_POWER, PROP_POWER_SIOP_LEVEL, &level);
 220         if (ret != 0)
 221                 goto check_rear;
 222
 223         if (level <= SIOP_NEGATIVE)
 224                 siop_domain = SIOP_NEGATIVE;
 225         else
 226                 siop_domain = SIOP_POSITIVE;
 227         siop_level = siop_domain * level;
 228
 229 check_rear:
 230         if (argv[1] == NULL)
 231                 goto out;
 232
 233         level = atoi(argv[1]);
 234         if (device_get_property(DEVICE_TYPE_POWER, PROP_POWER_REAR_LEVEL, &level) == 0)
 235                 rear_level = level;
 236
 237 out:
 238         level = SIOP_CTRL_VALUE(siop_level, rear_level);
 239         siop_level_action(level);
 240         return 0;
 241 #endif
 242 }
 243
 244 static int siop_mode_lcd(keynode_t *key_nodes, void *data)
 245 {
 246         int pm_state;
 247         if (vconf_get_int(VCONFKEY_PM_STATE, &pm_state) != 0)
 248                 _E("Fail to get vconf value for pm state\n");
 249         if (pm_state == VCONFKEY_PM_STATE_LCDOFF)
 250                 mode = MODE_LCD;
 251         else
 252                 mode = MODE_NONE;
 253         siop_level_action(siop);
 254         return 0;
 255 }
 256
 257 static void memcg_move_group(int pid, int oom_score_adj)
 258 {
 259         char buf[100];
 260         FILE *f;
 261         int ret, size;
 262         char exe_name[PATH_MAX];
 263
 264         if (get_cmdline_name(pid, exe_name, PATH_MAX) != 0) {
 265                 _E("fail to get process name(%d)", pid);
 266                 return;
 267         }
 268
 269         _SD("memcg_move_group : %s, pid = %d", exe_name, pid);
 270         if (oom_score_adj >= OOMADJ_BACKGRD_LOCKED)
 271                 sprintf(buf, "/sys/fs/cgroup/memory/background/cgroup.procs");
 272         else if (oom_score_adj >= OOMADJ_FOREGRD_LOCKED && oom_score_adj < OOMADJ_BACKGRD_LOCKED)
 273                 sprintf(buf, "/sys/fs/cgroup/memory/foreground/cgroup.procs");
 274         else
 275                 return;
 276
 277         f = fopen(buf, "w");
 278         if (f == NULL)
 279                 return;
 280         size = sprintf(buf, "%d", pid);
 281         if (fwrite(buf, size, 1, f) != 1)
 282                 _E("fwrite cgroup tasks : %d\n", pid);;
 283         fclose(f);
 284 }
 285
 286 int get_oom_score_adj(int pid, int *oom_score_adj)
 287 {
 288         char buf[PATH_MAX];
 289         FILE *fp;
 290
 291         if (pid < 0)
 292                 return -1;
 293
 294         fp = open_proc_oom_score_adj_file(pid, "r");
 295         if (fp == NULL)
 296                 return -1;
 297         if (fgets(buf, PATH_MAX, fp) == NULL) {
 298                 fclose(fp);
 299                 return -1;
 300         }
 301
 302         *oom_score_adj = atoi(buf);
 303         fclose(fp);
 304         return 0;
 305 }
 306
 307 int set_oom_score_adj(pid_t pid, int new_oom_score_adj)
 308 {
 309         FILE *fp;
 310         int old_oom_score_adj;
 311         char exe_name[PATH_MAX];
 312
 313         if (get_cmdline_name(pid, exe_name, PATH_MAX) < 0)
 314                 snprintf(exe_name, sizeof(exe_name), "Unknown (maybe dead)");
 315
 316         if (get_oom_score_adj(pid, &old_oom_score_adj) < 0)
 317                 return -1;
 318
 319         _SI("Process %s, pid %d, old_oom_score_adj %d new_oom_score_adj %d",
 320                 exe_name, pid, old_oom_score_adj, new_oom_score_adj);
 321
 322         if (new_oom_score_adj < OOMADJ_SU)
 323                 new_oom_score_adj = OOMADJ_SU;
 324
 325         fp = open_proc_oom_score_adj_file(pid, "w");
 326         if (fp == NULL)
 327                 return -1;
 328
 329         fprintf(fp, "%d", new_oom_score_adj);
 330         fclose(fp);
 331
 332         return 0;
 333 }
 334
 335 int set_su_oom_score_adj(pid_t pid)
 336 {
 337         return set_oom_score_adj(pid, OOMADJ_SU);
 338 }
 339
 340 int check_oom_score_adj(int oom_score_adj)
 341 {
 342         if (oom_score_adj != OOMADJ_FOREGRD_LOCKED && oom_score_adj != OOMADJ_FOREGRD_UNLOCKED)
 343                 return 0;
 344         return -1;
 345 }
 346
 347 int set_oom_score_adj_action(int argc, char **argv)
 348 {
 349         FILE *fp;
 350         int pid = -1;
 351         int new_oom_score_adj = 0;
 352
 353         if (argc < 2)
 354                 return -1;
 355         if ((pid = atoi(argv[0])) < 0 || (new_oom_score_adj = atoi(argv[1])) <= -20)
 356                 return -1;
 357
 358         _I("OOMADJ_SET : pid %d, new_oom_score_adj %d", pid, new_oom_score_adj);
 359
 360         fp = open_proc_oom_score_adj_file(pid, "w");
 361         if (fp == NULL)
 362                 return -1;
 363         if (new_oom_score_adj < OOMADJ_SU)
 364                 new_oom_score_adj = OOMADJ_SU;
 365         fprintf(fp, "%d", new_oom_score_adj);
 366         fclose(fp);
 367
 368         memcg_move_group(pid, new_oom_score_adj);
 369         return 0;
 370 }
 371
 372 int set_active_action(int argc, char **argv)
 373 {
 374         int pid = -1;
 375         int ret = 0;
 376         int oom_score_adj = 0;
 377
 378         if (argc < 1)
 379                 return -1;
 380         if ((pid = atoi(argv[0])) < 0)
 381                 return -1;
 382
 383         if (get_oom_score_adj(pid, &oom_score_adj) < 0)
 384                 return -1;
 385
 386         switch (oom_score_adj) {
 387         case OOMADJ_FOREGRD_LOCKED:
 388         case OOMADJ_BACKGRD_LOCKED:
 389         case OOMADJ_SU:
 390                 ret = 0;
 391                 break;
 392         case OOMADJ_FOREGRD_UNLOCKED:
 393                 ret = set_oom_score_adj((pid_t) pid, OOMADJ_FOREGRD_LOCKED);
 394                 break;
 395         case OOMADJ_BACKGRD_UNLOCKED:
 396                 ret = set_oom_score_adj((pid_t) pid, OOMADJ_BACKGRD_LOCKED);
 397                 break;
 398         case OOMADJ_INIT:
 399                 ret = set_oom_score_adj((pid_t) pid, OOMADJ_BACKGRD_LOCKED);
 400                 break;
 401         default:
 402                 if(oom_score_adj > OOMADJ_BACKGRD_UNLOCKED) {
 403                         ret = set_oom_score_adj((pid_t) pid, OOMADJ_BACKGRD_LOCKED);
 404                 } else {
 405                         _E("Unknown oom_score_adj value (%d) !", oom_score_adj);
 406                         ret = -1;
 407                 }
 408                 break;
 409         }
 410         set_enhance_pid(pid);
 411         return ret;
 412 }
 413
 414 int set_inactive_action(int argc, char **argv)
 415 {
 416         int pid = -1;
 417         int ret = 0;
 418         int oom_score_adj = 0;
 419
 420         if (argc < 1)
 421                 return -1;
 422         if ((pid = atoi(argv[0])) < 0)
 423                 return -1;
 424
 425         if (get_oom_score_adj(pid, &oom_score_adj) < 0)
 426                 return -1;
 427
 428         switch (oom_score_adj) {
 429         case OOMADJ_FOREGRD_UNLOCKED:
 430         case OOMADJ_BACKGRD_UNLOCKED:
 431         case OOMADJ_SU:
 432                 ret = 0;
 433                 break;
 434         case OOMADJ_FOREGRD_LOCKED:
 435                 ret = set_oom_score_adj((pid_t) pid, OOMADJ_FOREGRD_UNLOCKED);
 436                 break;
 437         case OOMADJ_BACKGRD_LOCKED:
 438                 ret = set_oom_score_adj((pid_t) pid, OOMADJ_BACKGRD_UNLOCKED);
 439                 break;
 440         case OOMADJ_INIT:
 441                 ret = set_oom_score_adj((pid_t) pid, OOMADJ_BACKGRD_UNLOCKED);
 442                 break;
 443         default:
 444                 if(oom_score_adj > OOMADJ_BACKGRD_UNLOCKED) {
 445                         ret = 0;
 446                 } else {
 447                         _E("Unknown oom_score_adj value (%d) !", oom_score_adj);
 448                         ret = -1;
 449                 }
 450                 break;
 451
 452         }
 453         set_enhance_pid(pid);
 454         return ret;
 455 }
 456
 457 int set_process_action(int argc, char **argv)
 458 {
 459         int pid = -1;
 460         int ret = 0;
 461
 462         if (argc < 1)
 463                 return -1;
 464         if ((pid = atoi(argv[0])) < 0)
 465                 return -1;
 466
 467         set_enhance_pid(pid);
 468         return ret;
 469 }
 470
 471 int set_process_group_action(int argc, char **argv)
 472 {
 473         int pid = -1;
 474         int ret = -1;
 475
 476         if (argc != 2)
 477                 return -1;
 478         if ((pid = atoi(argv[0])) < 0)
 479                 return -1;
 480
 481         if (strncmp(argv[1], PROCESS_VIP, strlen(PROCESS_VIP)) == 0)
 482                 ret = device_set_property(DEVICE_TYPE_PROCESS, PROP_PROCESS_MP_VIP, pid);
 483         else if (strncmp(argv[1], PROCESS_PERMANENT, strlen(PROCESS_PERMANENT)) == 0)
 484                 ret = device_set_property(DEVICE_TYPE_PROCESS, PROP_PROCESS_MP_PNP, pid);
 485
 486         if (ret == 0)
 487                 _I("%s : pid %d", argv[1], pid);
 488         else
 489                 _E("fail to set %s : pid %d",argv[1], pid);
 490         return 0;
 491 }
 492
 493 void check_siop_disable_process(int pid, char *default_name)
 494 {
 495         int oom_score_adj;
 496         char exe_name[PATH_MAX];
 497         if (pid <= 0)
 498                 return;
 499
 500         if (get_oom_score_adj(pid, &oom_score_adj) < 0) {
 501                 _E("fail to get adj value of pid: %d (%d)", pid);
 502                 return;
 503         }
 504
 505         if (get_cmdline_name(pid, exe_name, PATH_MAX) != 0) {
 506                 _E("fail to check cmdline: %d (%s)", pid, default_name);
 507                 return;
 508         }
 509
 510         if (strncmp(exe_name, default_name, strlen(default_name)) != 0) {
 511                 return;
 512         }
 513
 514         switch (oom_score_adj) {
 515         case OOMADJ_FOREGRD_LOCKED:
 516         case OOMADJ_FOREGRD_UNLOCKED:
 517                 siop_level_action(0);
 518                 vconf_set_int(VCONFKEY_INTERNAL_PRIVATE_SIOP_DISABLE, 1);
 519                 return;
 520         case OOMADJ_BACKGRD_LOCKED:
 521         case OOMADJ_BACKGRD_UNLOCKED:
 522         case OOMADJ_SU:
 523                 vconf_set_int(VCONFKEY_INTERNAL_PRIVATE_SIOP_DISABLE, 0);
 524         }
 525         return;
 526 }
 527
 528 static DBusMessage *dbus_proc_handler(E_DBus_Object *obj, DBusMessage *msg)
 529 {
 530         DBusError err;
 531         DBusMessageIter iter;
 532         DBusMessage *reply;
 533         pid_t pid;
 534         int ret;
 535         int argc;
 536         char *type_str;
 537         char *argv;
 538
 539         dbus_error_init(&err);
 540
 541         if (!dbus_message_get_args(msg, &err,
 542                     DBUS_TYPE_STRING, &type_str,
 543                     DBUS_TYPE_INT32, &argc,
 544                     DBUS_TYPE_STRING, &argv, DBUS_TYPE_INVALID)) {
 545                 _E("there is no message");
 546                 ret = -EINVAL;
 547                 goto out;
 548         }
 549
 550         if (argc < 0) {
 551                 _E("message is invalid!");
 552                 ret = -EINVAL;
 553                 goto out;
 554         }
 555
 556         pid = get_edbus_sender_pid(msg);
 557         if (kill(pid, 0) == -1) {
 558                 _E("%d process does not exist, dbus ignored!", pid);
 559                 ret = -ESRCH;
 560                 goto out;
 561         }
 562
 563         if (strncmp(type_str, PREDEF_FOREGRD, strlen(PREDEF_FOREGRD)) == 0)
 564                 ret = set_process_action(argc, (char **)&argv);
 565         else if (strncmp(type_str, PREDEF_BACKGRD, strlen(PREDEF_BACKGRD)) == 0)
 566                 ret = set_process_action(argc, (char **)&argv);
 567         else if (strncmp(type_str, PREDEF_ACTIVE, strlen(PREDEF_ACTIVE)) == 0)
 568                 ret = set_active_action(argc, (char **)&argv);
 569         else if (strncmp(type_str, PREDEF_INACTIVE, strlen(PREDEF_INACTIVE)) == 0)
 570                 ret = set_inactive_action(argc, (char **)&argv);
 571 out:
 572         reply = dbus_message_new_method_return(msg);
 573         dbus_message_iter_init_append(reply, &iter);
 574         dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
 575
 576         return reply;
 577 }
 578
 579 static DBusMessage *dbus_oom_handler(E_DBus_Object *obj, DBusMessage *msg)
 580 {
 581         DBusError err;
 582         DBusMessageIter iter;
 583         DBusMessage *reply;
 584         pid_t pid;
 585         int ret;
 586         int argc;
 587         char *type_str;
 588         char *argv[2];
 589
 590         dbus_error_init(&err);
 591
 592         if (!dbus_message_get_args(msg, &err,
 593                     DBUS_TYPE_STRING, &type_str,
 594                     DBUS_TYPE_INT32, &argc,
 595                     DBUS_TYPE_STRING, &argv[0],
 596                     DBUS_TYPE_STRING, &argv[1], DBUS_TYPE_INVALID)) {
 597                 _E("there is no message");
 598                 ret = -EINVAL;
 599                 goto out;
 600         }
 601
 602         if (argc < 0) {
 603                 _E("message is invalid!");
 604                 ret = -EINVAL;
 605                 goto out;
 606         }
 607
 608         pid = get_edbus_sender_pid(msg);
 609         if (kill(pid, 0) == -1) {
 610                 _E("%d process does not exist, dbus ignored!", pid);
 611                 ret = -ESRCH;
 612                 goto out;
 613         }
 614
 615         if (strncmp(type_str, OOMADJ_SET, strlen(OOMADJ_SET)) == 0)
 616                 ret = set_oom_score_adj_action(argc, (char **)&argv);
 617         else if (strncmp(type_str, PROCESS_GROUP_SET, strlen(PROCESS_GROUP_SET)) == 0)
 618                 ret = set_process_group_action(argc, (char **)&argv);
 619 out:
 620         reply = dbus_message_new_method_return(msg);
 621         dbus_message_iter_init_append(reply, &iter);
 622         dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
 623
 624         return reply;
 625 }
 626
 627 static DBusMessage *dbus_get_siop_level(E_DBus_Object *obj, DBusMessage *msg)
 628 {
 629         DBusMessageIter iter;
 630         DBusMessage *reply;
 631         int level;
 632
 633         level = SIOP_VALUE(siop_domain, siop);
 634         reply = dbus_message_new_method_return(msg);
 635         dbus_message_iter_init_append(reply, &iter);
 636         dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &level);
 637         return reply;
 638 }
 639
 640 static DBusMessage *dbus_get_rear_level(E_DBus_Object *obj, DBusMessage *msg)
 641 {
 642         DBusMessageIter iter;
 643         DBusMessage *reply;
 644         int level;
 645
 646         level = REAR_VALUE(siop);
 647         reply = dbus_message_new_method_return(msg);
 648         dbus_message_iter_init_append(reply, &iter);
 649         dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &level);
 650         return reply;
 651 }
 652
 653 static DBusMessage *dbus_set_siop_level(E_DBus_Object *obj, DBusMessage *msg)
 654 {
 655         DBusError err;
 656         DBusMessageIter iter;
 657         DBusMessage *reply;
 658         int ret;
 659         char *argv[2];
 660
 661         dbus_error_init(&err);
 662
 663         if (!dbus_message_get_args(msg, &err,
 664                     DBUS_TYPE_STRING, &argv[0],
 665                     DBUS_TYPE_STRING, &argv[1], DBUS_TYPE_INVALID)) {
 666                 _E("there is no message");
 667                 ret = -EINVAL;
 668                 goto out;
 669         }
 670         ret = siop_changed(2, (char **)&argv);
 671 out:
 672         reply = dbus_message_new_method_return(msg);
 673         dbus_message_iter_init_append(reply, &iter);
 674         dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
 675
 676         return reply;
 677 }
 678
 679 static void dbus_proc_oomadj_set_signal_handler(void *data, DBusMessage *msg)
 680
 681 {
 682         DBusError err;
 683         pid_t pid;
 684         int ret = -EINVAL;
 685         int argc;
 686         char *type_str;
 687         char *argv;
 688
 689         dbus_error_init(&err);
 690
 691         if (!dbus_message_get_args(msg, &err,
 692                     DBUS_TYPE_STRING, &type_str,
 693                     DBUS_TYPE_INT32, &argc,
 694                     DBUS_TYPE_STRING, &argv, DBUS_TYPE_INVALID)) {
 695                 _E("there is no message");
 696                 return;
 697         }
 698
 699         if (argc < 0) {
 700                 _E("message is invalid!");
 701                 return;
 702         }
 703
 704         pid = get_edbus_sender_pid(msg);
 705         if (kill(pid, 0) == -1) {
 706                 _E("%d process does not exist, dbus ignored!", pid);
 707                 return;
 708         }
 709
 710         if (strncmp(type_str, PREDEF_FOREGRD, strlen(PREDEF_FOREGRD)) == 0)
 711                 ret = set_process_action(argc, (char **)&argv);
 712         else if (strncmp(type_str, PREDEF_BACKGRD, strlen(PREDEF_BACKGRD)) == 0)
 713                 ret = set_process_action(argc, (char **)&argv);
 714         else if (strncmp(type_str, PREDEF_ACTIVE, strlen(PREDEF_ACTIVE)) == 0)
 715                 ret = set_active_action(argc, (char **)&argv);
 716         else if (strncmp(type_str, PREDEF_INACTIVE, strlen(PREDEF_INACTIVE)) == 0)
 717                 ret = set_inactive_action(argc, (char **)&argv);
 718
 719         if (ret < 0)
 720                 _E("set_process_action error!");
 721 }
 722
 723
 724 static const struct edbus_method edbus_methods[] = {
 725         { PREDEF_FOREGRD, "sis", "i", dbus_proc_handler },
 726         { PREDEF_BACKGRD, "sis", "i", dbus_proc_handler },
 727         { PREDEF_ACTIVE, "sis", "i", dbus_proc_handler },
 728         { PREDEF_INACTIVE, "sis", "i", dbus_proc_handler },
 729         { OOMADJ_SET, "siss", "i", dbus_oom_handler },
 730         { PROCESS_GROUP_SET, "siss", "i", dbus_oom_handler },
 731         { SIOP_LEVEL_GET, NULL, "i", dbus_get_siop_level },
 732         { REAR_LEVEL_GET, NULL, "i", dbus_get_rear_level },
 733         { SIOP_LEVEL_SET, "ss", "i", dbus_set_siop_level },
 734 };
 735
 736 static int proc_booting_done(void *data)
 737 {
 738         register_action(SIOP_CHANGED, siop_changed, NULL, NULL);
 739         if (vconf_notify_key_changed(VCONFKEY_PM_STATE, (void *)siop_mode_lcd, NULL) < 0)
 740                 _E("Vconf notify key chaneged failed: KEY(%s)", VCONFKEY_PM_STATE);
 741         siop_mode_lcd(NULL, NULL);
 742         return 0;
 743 }
 744 static void process_init(void *data)
 745 {
 746         int ret;
 747
 748         register_edbus_signal_handler(DEVICED_PATH_PROCESS, DEVICED_INTERFACE_PROCESS,
 749                         SIGNAL_NAME_OOMADJ_SET,
 750                     dbus_proc_oomadj_set_signal_handler);
 751
 752         ret = register_edbus_method(DEVICED_PATH_PROCESS, edbus_methods, ARRAY_SIZE(edbus_methods));
 753         if (ret < 0)
 754                 _E("fail to init edbus method(%d)", ret);
 755
 756         register_action(PREDEF_FOREGRD, set_process_action, NULL, NULL);
 757         register_action(PREDEF_BACKGRD, set_process_action, NULL, NULL);
 758         register_action(PREDEF_ACTIVE, set_active_action, NULL, NULL);
 759         register_action(PREDEF_INACTIVE, set_inactive_action, NULL, NULL);
 760         register_action(OOMADJ_SET, set_oom_score_adj_action, NULL, NULL);
 761         register_action(PROCESS_GROUP_SET, set_process_group_action, NULL, NULL);
 762
 763         register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, proc_booting_done);
 764 }
 765
 766 static const struct device_ops process_device_ops = {
 767         .priority = DEVICE_PRIORITY_NORMAL,
 768         .name     = "process",
 769         .init     = process_init,
 770 };
 771
 772 DEVICE_OPS_REGISTER(&process_device_ops)