kernel/taskstats.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * taskstats.c - Export per-task statistics to userland
   4  *
   5  * Copyright (C) Shailabh Nagar, IBM Corp. 2006
   6  *           (C) Balbir Singh,   IBM Corp. 2006
   7  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/taskstats_kern.h>
  11 #include <linux/tsacct_kern.h>
  12 #include <linux/delayacct.h>
  13 #include <linux/cpumask.h>
  14 #include <linux/percpu.h>
  15 #include <linux/slab.h>
  16 #include <linux/cgroupstats.h>
  17 #include <linux/cgroup.h>
  18 #include <linux/fs.h>
  19 #include <linux/file.h>
  20 #include <linux/pid_namespace.h>
  21 #include <net/genetlink.h>
  22 #include <linux/atomic.h>
  23 #include <linux/sched/cputime.h>
  24
  25 /*
  26  * Maximum length of a cpumask that can be specified in
  27  * the TASKSTATS_CMD_ATTR_REGISTER/DEREGISTER_CPUMASK attribute
  28  */
  29 #define TASKSTATS_CPUMASK_MAXLEN        (100+6*NR_CPUS)
  30
  31 static DEFINE_PER_CPU(__u32, taskstats_seqnum);
  32 static int family_registered;
  33 struct kmem_cache *taskstats_cache;
  34
  35 static struct genl_family family;
  36
  37 static const struct nla_policy taskstats_cmd_get_policy[] = {
  38         [TASKSTATS_CMD_ATTR_PID]  = { .type = NLA_U32 },
  39         [TASKSTATS_CMD_ATTR_TGID] = { .type = NLA_U32 },
  40         [TASKSTATS_CMD_ATTR_REGISTER_CPUMASK] = { .type = NLA_STRING },
  41         [TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK] = { .type = NLA_STRING },};
  42
  43 static const struct nla_policy cgroupstats_cmd_get_policy[] = {
  44         [CGROUPSTATS_CMD_ATTR_FD] = { .type = NLA_U32 },
  45 };
  46
  47 struct listener {
  48         struct list_head list;
  49         pid_t pid;
  50         char valid;
  51 };
  52
  53 struct listener_list {
  54         struct rw_semaphore sem;
  55         struct list_head list;
  56 };
  57 static DEFINE_PER_CPU(struct listener_list, listener_array);
  58
  59 enum actions {
  60         REGISTER,
  61         DEREGISTER,
  62         CPU_DONT_CARE
  63 };
  64
  65 static int prepare_reply(struct genl_info *info, u8 cmd, struct sk_buff **skbp,
  66                                 size_t size)
  67 {
  68         struct sk_buff *skb;
  69         void *reply;
  70
  71         /*
  72          * If new attributes are added, please revisit this allocation
  73          */
  74         skb = genlmsg_new(size, GFP_KERNEL);
  75         if (!skb)
  76                 return -ENOMEM;
  77
  78         if (!info) {
  79                 int seq = this_cpu_inc_return(taskstats_seqnum) - 1;
  80
  81                 reply = genlmsg_put(skb, 0, seq, &family, 0, cmd);
  82         } else
  83                 reply = genlmsg_put_reply(skb, info, &family, 0, cmd);
  84         if (reply == NULL) {
  85                 nlmsg_free(skb);
  86                 return -EINVAL;
  87         }
  88
  89         *skbp = skb;
  90         return 0;
  91 }
  92
  93 /*
  94  * Send taskstats data in @skb to listener with nl_pid @pid
  95  */
  96 static int send_reply(struct sk_buff *skb, struct genl_info *info)
  97 {
  98         struct genlmsghdr *genlhdr = nlmsg_data(nlmsg_hdr(skb));
  99         void *reply = genlmsg_data(genlhdr);
 100
 101         genlmsg_end(skb, reply);
 102
 103         return genlmsg_reply(skb, info);
 104 }
 105
 106 /*
 107  * Send taskstats data in @skb to listeners registered for @cpu's exit data
 108  */
 109 static void send_cpu_listeners(struct sk_buff *skb,
 110                                         struct listener_list *listeners)
 111 {
 112         struct genlmsghdr *genlhdr = nlmsg_data(nlmsg_hdr(skb));
 113         struct listener *s, *tmp;
 114         struct sk_buff *skb_next, *skb_cur = skb;
 115         void *reply = genlmsg_data(genlhdr);
 116         int delcount = 0;
 117
 118         genlmsg_end(skb, reply);
 119
 120         down_read(&listeners->sem);
 121         list_for_each_entry(s, &listeners->list, list) {
 122                 int rc;
 123
 124                 skb_next = NULL;
 125                 if (!list_is_last(&s->list, &listeners->list)) {
 126                         skb_next = skb_clone(skb_cur, GFP_KERNEL);
 127                         if (!skb_next)
 128                                 break;
 129                 }
 130                 rc = genlmsg_unicast(&init_net, skb_cur, s->pid);
 131                 if (rc == -ECONNREFUSED) {
 132                         s->valid = 0;
 133                         delcount++;
 134                 }
 135                 skb_cur = skb_next;
 136         }
 137         up_read(&listeners->sem);
 138
 139         if (skb_cur)
 140                 nlmsg_free(skb_cur);
 141
 142         if (!delcount)
 143                 return;
 144
 145         /* Delete invalidated entries */
 146         down_write(&listeners->sem);
 147         list_for_each_entry_safe(s, tmp, &listeners->list, list) {
 148                 if (!s->valid) {
 149                         list_del(&s->list);
 150                         kfree(s);
 151                 }
 152         }
 153         up_write(&listeners->sem);
 154 }
 155
 156 static void fill_stats(struct user_namespace *user_ns,
 157                        struct pid_namespace *pid_ns,
 158                        struct task_struct *tsk, struct taskstats *stats)
 159 {
 160         memset(stats, 0, sizeof(*stats));
 161         /*
 162          * Each accounting subsystem adds calls to its functions to
 163          * fill in relevant parts of struct taskstsats as follows
 164          *
 165          *      per-task-foo(stats, tsk);
 166          */
 167
 168         delayacct_add_tsk(stats, tsk);
 169
 170         /* fill in basic acct fields */
 171         stats->version = TASKSTATS_VERSION;
 172         stats->nvcsw = tsk->nvcsw;
 173         stats->nivcsw = tsk->nivcsw;
 174         bacct_add_tsk(user_ns, pid_ns, stats, tsk);
 175
 176         /* fill in extended acct fields */
 177         xacct_add_tsk(stats, tsk);
 178 }
 179
 180 static int fill_stats_for_pid(pid_t pid, struct taskstats *stats)
 181 {
 182         struct task_struct *tsk;
 183
 184         tsk = find_get_task_by_vpid(pid);
 185         if (!tsk)
 186                 return -ESRCH;
 187         fill_stats(current_user_ns(), task_active_pid_ns(current), tsk, stats);
 188         put_task_struct(tsk);
 189         return 0;
 190 }
 191
 192 static int fill_stats_for_tgid(pid_t tgid, struct taskstats *stats)
 193 {
 194         struct task_struct *tsk, *first;
 195         unsigned long flags;
 196         int rc = -ESRCH;
 197         u64 delta, utime, stime;
 198         u64 start_time;
 199
 200         /*
 201          * Add additional stats from live tasks except zombie thread group
 202          * leaders who are already counted with the dead tasks
 203          */
 204         rcu_read_lock();
 205         first = find_task_by_vpid(tgid);
 206
 207         if (!first || !lock_task_sighand(first, &flags))
 208                 goto out;
 209
 210         if (first->signal->stats)
 211                 memcpy(stats, first->signal->stats, sizeof(*stats));
 212         else
 213                 memset(stats, 0, sizeof(*stats));
 214
 215         tsk = first;
 216         start_time = ktime_get_ns();
 217         do {
 218                 if (tsk->exit_state)
 219                         continue;
 220                 /*
 221                  * Accounting subsystem can call its functions here to
 222                  * fill in relevant parts of struct taskstsats as follows
 223                  *
 224                  *      per-task-foo(stats, tsk);
 225                  */
 226                 delayacct_add_tsk(stats, tsk);
 227
 228                 /* calculate task elapsed time in nsec */
 229                 delta = start_time - tsk->start_time;
 230                 /* Convert to micro seconds */
 231                 do_div(delta, NSEC_PER_USEC);
 232                 stats->ac_etime += delta;
 233
 234                 task_cputime(tsk, &utime, &stime);
 235                 stats->ac_utime += div_u64(utime, NSEC_PER_USEC);
 236                 stats->ac_stime += div_u64(stime, NSEC_PER_USEC);
 237
 238                 stats->nvcsw += tsk->nvcsw;
 239                 stats->nivcsw += tsk->nivcsw;
 240         } while_each_thread(first, tsk);
 241
 242         unlock_task_sighand(first, &flags);
 243         rc = 0;
 244 out:
 245         rcu_read_unlock();
 246
 247         stats->version = TASKSTATS_VERSION;
 248         /*
 249          * Accounting subsystems can also add calls here to modify
 250          * fields of taskstats.
 251          */
 252         return rc;
 253 }
 254
 255 static void fill_tgid_exit(struct task_struct *tsk)
 256 {
 257         unsigned long flags;
 258
 259         spin_lock_irqsave(&tsk->sighand->siglock, flags);
 260         if (!tsk->signal->stats)
 261                 goto ret;
 262
 263         /*
 264          * Each accounting subsystem calls its functions here to
 265          * accumalate its per-task stats for tsk, into the per-tgid structure
 266          *
 267          *      per-task-foo(tsk->signal->stats, tsk);
 268          */
 269         delayacct_add_tsk(tsk->signal->stats, tsk);
 270 ret:
 271         spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
 272         return;
 273 }
 274
 275 static int add_del_listener(pid_t pid, const struct cpumask *mask, int isadd)
 276 {
 277         struct listener_list *listeners;
 278         struct listener *s, *tmp, *s2;
 279         unsigned int cpu;
 280         int ret = 0;
 281
 282         if (!cpumask_subset(mask, cpu_possible_mask))
 283                 return -EINVAL;
 284
 285         if (current_user_ns() != &init_user_ns)
 286                 return -EINVAL;
 287
 288         if (task_active_pid_ns(current) != &init_pid_ns)
 289                 return -EINVAL;
 290
 291         if (isadd == REGISTER) {
 292                 for_each_cpu(cpu, mask) {
 293                         s = kmalloc_node(sizeof(struct listener),
 294                                         GFP_KERNEL, cpu_to_node(cpu));
 295                         if (!s) {
 296                                 ret = -ENOMEM;
 297                                 goto cleanup;
 298                         }
 299                         s->pid = pid;
 300                         s->valid = 1;
 301
 302                         listeners = &per_cpu(listener_array, cpu);
 303                         down_write(&listeners->sem);
 304                         list_for_each_entry(s2, &listeners->list, list) {
 305                                 if (s2->pid == pid && s2->valid)
 306                                         goto exists;
 307                         }
 308                         list_add(&s->list, &listeners->list);
 309                         s = NULL;
 310 exists:
 311                         up_write(&listeners->sem);
 312                         kfree(s); /* nop if NULL */
 313                 }
 314                 return 0;
 315         }
 316
 317         /* Deregister or cleanup */
 318 cleanup:
 319         for_each_cpu(cpu, mask) {
 320                 listeners = &per_cpu(listener_array, cpu);
 321                 down_write(&listeners->sem);
 322                 list_for_each_entry_safe(s, tmp, &listeners->list, list) {
 323                         if (s->pid == pid) {
 324                                 list_del(&s->list);
 325                                 kfree(s);
 326                                 break;
 327                         }
 328                 }
 329                 up_write(&listeners->sem);
 330         }
 331         return ret;
 332 }
 333
 334 static int parse(struct nlattr *na, struct cpumask *mask)
 335 {
 336         char *data;
 337         int len;
 338         int ret;
 339
 340         if (na == NULL)
 341                 return 1;
 342         len = nla_len(na);
 343         if (len > TASKSTATS_CPUMASK_MAXLEN)
 344                 return -E2BIG;
 345         if (len < 1)
 346                 return -EINVAL;
 347         data = kmalloc(len, GFP_KERNEL);
 348         if (!data)
 349                 return -ENOMEM;
 350         nla_strscpy(data, na, len);
 351         ret = cpulist_parse(data, mask);
 352         kfree(data);
 353         return ret;
 354 }
 355
 356 static struct taskstats *mk_reply(struct sk_buff *skb, int type, u32 pid)
 357 {
 358         struct nlattr *na, *ret;
 359         int aggr;
 360
 361         aggr = (type == TASKSTATS_TYPE_PID)
 362                         ? TASKSTATS_TYPE_AGGR_PID
 363                         : TASKSTATS_TYPE_AGGR_TGID;
 364
 365         na = nla_nest_start_noflag(skb, aggr);
 366         if (!na)
 367                 goto err;
 368
 369         if (nla_put(skb, type, sizeof(pid), &pid) < 0) {
 370                 nla_nest_cancel(skb, na);
 371                 goto err;
 372         }
 373         ret = nla_reserve_64bit(skb, TASKSTATS_TYPE_STATS,
 374                                 sizeof(struct taskstats), TASKSTATS_TYPE_NULL);
 375         if (!ret) {
 376                 nla_nest_cancel(skb, na);
 377                 goto err;
 378         }
 379         nla_nest_end(skb, na);
 380
 381         return nla_data(ret);
 382 err:
 383         return NULL;
 384 }
 385
 386 static int cgroupstats_user_cmd(struct sk_buff *skb, struct genl_info *info)
 387 {
 388         int rc = 0;
 389         struct sk_buff *rep_skb;
 390         struct cgroupstats *stats;
 391         struct nlattr *na;
 392         size_t size;
 393         u32 fd;
 394         struct fd f;
 395
 396         na = info->attrs[CGROUPSTATS_CMD_ATTR_FD];
 397         if (!na)
 398                 return -EINVAL;
 399
 400         fd = nla_get_u32(info->attrs[CGROUPSTATS_CMD_ATTR_FD]);
 401         f = fdget(fd);
 402         if (!f.file)
 403                 return 0;
 404
 405         size = nla_total_size(sizeof(struct cgroupstats));
 406
 407         rc = prepare_reply(info, CGROUPSTATS_CMD_NEW, &rep_skb,
 408                                 size);
 409         if (rc < 0)
 410                 goto err;
 411
 412         na = nla_reserve(rep_skb, CGROUPSTATS_TYPE_CGROUP_STATS,
 413                                 sizeof(struct cgroupstats));
 414         if (na == NULL) {
 415                 nlmsg_free(rep_skb);
 416                 rc = -EMSGSIZE;
 417                 goto err;
 418         }
 419
 420         stats = nla_data(na);
 421         memset(stats, 0, sizeof(*stats));
 422
 423         rc = cgroupstats_build(stats, f.file->f_path.dentry);
 424         if (rc < 0) {
 425                 nlmsg_free(rep_skb);
 426                 goto err;
 427         }
 428
 429         rc = send_reply(rep_skb, info);
 430
 431 err:
 432         fdput(f);
 433         return rc;
 434 }
 435
 436 static int cmd_attr_register_cpumask(struct genl_info *info)
 437 {
 438         cpumask_var_t mask;
 439         int rc;
 440
 441         if (!alloc_cpumask_var(&mask, GFP_KERNEL))
 442                 return -ENOMEM;
 443         rc = parse(info->attrs[TASKSTATS_CMD_ATTR_REGISTER_CPUMASK], mask);
 444         if (rc < 0)
 445                 goto out;
 446         rc = add_del_listener(info->snd_portid, mask, REGISTER);
 447 out:
 448         free_cpumask_var(mask);
 449         return rc;
 450 }
 451
 452 static int cmd_attr_deregister_cpumask(struct genl_info *info)
 453 {
 454         cpumask_var_t mask;
 455         int rc;
 456
 457         if (!alloc_cpumask_var(&mask, GFP_KERNEL))
 458                 return -ENOMEM;
 459         rc = parse(info->attrs[TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK], mask);
 460         if (rc < 0)
 461                 goto out;
 462         rc = add_del_listener(info->snd_portid, mask, DEREGISTER);
 463 out:
 464         free_cpumask_var(mask);
 465         return rc;
 466 }
 467
 468 static size_t taskstats_packet_size(void)
 469 {
 470         size_t size;
 471
 472         size = nla_total_size(sizeof(u32)) +
 473                 nla_total_size_64bit(sizeof(struct taskstats)) +
 474                 nla_total_size(0);
 475
 476         return size;
 477 }
 478
 479 static int cmd_attr_pid(struct genl_info *info)
 480 {
 481         struct taskstats *stats;
 482         struct sk_buff *rep_skb;
 483         size_t size;
 484         u32 pid;
 485         int rc;
 486
 487         size = taskstats_packet_size();
 488
 489         rc = prepare_reply(info, TASKSTATS_CMD_NEW, &rep_skb, size);
 490         if (rc < 0)
 491                 return rc;
 492
 493         rc = -EINVAL;
 494         pid = nla_get_u32(info->attrs[TASKSTATS_CMD_ATTR_PID]);
 495         stats = mk_reply(rep_skb, TASKSTATS_TYPE_PID, pid);
 496         if (!stats)
 497                 goto err;
 498
 499         rc = fill_stats_for_pid(pid, stats);
 500         if (rc < 0)
 501                 goto err;
 502         return send_reply(rep_skb, info);
 503 err:
 504         nlmsg_free(rep_skb);
 505         return rc;
 506 }
 507
 508 static int cmd_attr_tgid(struct genl_info *info)
 509 {
 510         struct taskstats *stats;
 511         struct sk_buff *rep_skb;
 512         size_t size;
 513         u32 tgid;
 514         int rc;
 515
 516         size = taskstats_packet_size();
 517
 518         rc = prepare_reply(info, TASKSTATS_CMD_NEW, &rep_skb, size);
 519         if (rc < 0)
 520                 return rc;
 521
 522         rc = -EINVAL;
 523         tgid = nla_get_u32(info->attrs[TASKSTATS_CMD_ATTR_TGID]);
 524         stats = mk_reply(rep_skb, TASKSTATS_TYPE_TGID, tgid);
 525         if (!stats)
 526                 goto err;
 527
 528         rc = fill_stats_for_tgid(tgid, stats);
 529         if (rc < 0)
 530                 goto err;
 531         return send_reply(rep_skb, info);
 532 err:
 533         nlmsg_free(rep_skb);
 534         return rc;
 535 }
 536
 537 static int taskstats_user_cmd(struct sk_buff *skb, struct genl_info *info)
 538 {
 539         if (info->attrs[TASKSTATS_CMD_ATTR_REGISTER_CPUMASK])
 540                 return cmd_attr_register_cpumask(info);
 541         else if (info->attrs[TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK])
 542                 return cmd_attr_deregister_cpumask(info);
 543         else if (info->attrs[TASKSTATS_CMD_ATTR_PID])
 544                 return cmd_attr_pid(info);
 545         else if (info->attrs[TASKSTATS_CMD_ATTR_TGID])
 546                 return cmd_attr_tgid(info);
 547         else
 548                 return -EINVAL;
 549 }
 550
 551 static struct taskstats *taskstats_tgid_alloc(struct task_struct *tsk)
 552 {
 553         struct signal_struct *sig = tsk->signal;
 554         struct taskstats *stats_new, *stats;
 555
 556         /* Pairs with smp_store_release() below. */
 557         stats = smp_load_acquire(&sig->stats);
 558         if (stats || thread_group_empty(tsk))
 559                 return stats;
 560
 561         /* No problem if kmem_cache_zalloc() fails */
 562         stats_new = kmem_cache_zalloc(taskstats_cache, GFP_KERNEL);
 563
 564         spin_lock_irq(&tsk->sighand->siglock);
 565         stats = sig->stats;
 566         if (!stats) {
 567                 /*
 568                  * Pairs with smp_store_release() above and order the
 569                  * kmem_cache_zalloc().
 570                  */
 571                 smp_store_release(&sig->stats, stats_new);
 572                 stats = stats_new;
 573                 stats_new = NULL;
 574         }
 575         spin_unlock_irq(&tsk->sighand->siglock);
 576
 577         if (stats_new)
 578                 kmem_cache_free(taskstats_cache, stats_new);
 579
 580         return stats;
 581 }
 582
 583 /* Send pid data out on exit */
 584 void taskstats_exit(struct task_struct *tsk, int group_dead)
 585 {
 586         int rc;
 587         struct listener_list *listeners;
 588         struct taskstats *stats;
 589         struct sk_buff *rep_skb;
 590         size_t size;
 591         int is_thread_group;
 592
 593         if (!family_registered)
 594                 return;
 595
 596         /*
 597          * Size includes space for nested attributes
 598          */
 599         size = taskstats_packet_size();
 600
 601         is_thread_group = !!taskstats_tgid_alloc(tsk);
 602         if (is_thread_group) {
 603                 /* PID + STATS + TGID + STATS */
 604                 size = 2 * size;
 605                 /* fill the tsk->signal->stats structure */
 606                 fill_tgid_exit(tsk);
 607         }
 608
 609         listeners = raw_cpu_ptr(&listener_array);
 610         if (list_empty(&listeners->list))
 611                 return;
 612
 613         rc = prepare_reply(NULL, TASKSTATS_CMD_NEW, &rep_skb, size);
 614         if (rc < 0)
 615                 return;
 616
 617         stats = mk_reply(rep_skb, TASKSTATS_TYPE_PID,
 618                          task_pid_nr_ns(tsk, &init_pid_ns));
 619         if (!stats)
 620                 goto err;
 621
 622         fill_stats(&init_user_ns, &init_pid_ns, tsk, stats);
 623
 624         /*
 625          * Doesn't matter if tsk is the leader or the last group member leaving
 626          */
 627         if (!is_thread_group || !group_dead)
 628                 goto send;
 629
 630         stats = mk_reply(rep_skb, TASKSTATS_TYPE_TGID,
 631                          task_tgid_nr_ns(tsk, &init_pid_ns));
 632         if (!stats)
 633                 goto err;
 634
 635         memcpy(stats, tsk->signal->stats, sizeof(*stats));
 636
 637 send:
 638         send_cpu_listeners(rep_skb, listeners);
 639         return;
 640 err:
 641         nlmsg_free(rep_skb);
 642 }
 643
 644 static const struct genl_ops taskstats_ops[] = {
 645         {
 646                 .cmd            = TASKSTATS_CMD_GET,
 647                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
 648                 .doit           = taskstats_user_cmd,
 649                 .policy         = taskstats_cmd_get_policy,
 650                 .maxattr        = ARRAY_SIZE(taskstats_cmd_get_policy) - 1,
 651                 .flags          = GENL_ADMIN_PERM,
 652         },
 653         {
 654                 .cmd            = CGROUPSTATS_CMD_GET,
 655                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
 656                 .doit           = cgroupstats_user_cmd,
 657                 .policy         = cgroupstats_cmd_get_policy,
 658                 .maxattr        = ARRAY_SIZE(cgroupstats_cmd_get_policy) - 1,
 659         },
 660 };
 661
 662 static struct genl_family family __ro_after_init = {
 663         .name           = TASKSTATS_GENL_NAME,
 664         .version        = TASKSTATS_GENL_VERSION,
 665         .module         = THIS_MODULE,
 666         .ops            = taskstats_ops,
 667         .n_ops          = ARRAY_SIZE(taskstats_ops),
 668 };
 669
 670 /* Needed early in initialization */
 671 void __init taskstats_init_early(void)
 672 {
 673         unsigned int i;
 674
 675         taskstats_cache = KMEM_CACHE(taskstats, SLAB_PANIC);
 676         for_each_possible_cpu(i) {
 677                 INIT_LIST_HEAD(&(per_cpu(listener_array, i).list));
 678                 init_rwsem(&(per_cpu(listener_array, i).sem));
 679         }
 680 }
 681
 682 static int __init taskstats_init(void)
 683 {
 684         int rc;
 685
 686         rc = genl_register_family(&family);
 687         if (rc)
 688                 return rc;
 689
 690         family_registered = 1;
 691         pr_info("registered taskstats version %d\n", TASKSTATS_GENL_VERSION);
 692         return 0;
 693 }
 694
 695 /*
 696  * late initcall ensures initialization of statistics collection
 697  * mechanisms precedes initialization of the taskstats interface
 698  */
 699 late_initcall(taskstats_init);