kernel/syscall/corectl.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #include <sys/proc.h>
  27 #include <sys/systm.h>
  28 #include <sys/param.h>
  29 #include <sys/atomic.h>
  30 #include <sys/kmem.h>
  31 #include <sys/sysmacros.h>
  32 #include <sys/procset.h>
  33 #include <sys/corectl.h>
  34 #include <sys/zone.h>
  35 #include <sys/cmn_err.h>
  36 #include <sys/policy.h>
  37
  38 /*
  39  * Core File Settings
  40  * ------------------
  41  *
  42  * A process's core file path and content live in separate reference-counted
  43  * structures. The corectl_content_t structure is fairly straightforward --
  44  * the only subtlety is that we only really _need_ the mutex on architectures
  45  * on which 64-bit memory operations are not atomic. The corectl_path_t
  46  * structure is slightly trickier in that it contains a refstr_t rather than
  47  * just a char * string. This is to allow consumers of the data in that
  48  * structure (the core dumping sub-system for example) to safely use the
  49  * string without holding any locks on it in light of updates.
  50  *
  51  * At system and zone boot, init_core() sets init(1M)'s core file path and
  52  * content to the same value as the fields core_default_path and
  53  * core_default_content respectively (for the global zone). All subsequent
  54  * children of init(1M) reference those same settings. During boot coreadm(1M)
  55  * is invoked with the -u option to update the system settings from
  56  * /etc/coreadm.conf. This has the effect of also changing the values in
  57  * core_default_path and core_default_content which updates the core file
  58  * settings for all processes in the zone.  Each zone has different default
  59  * settings; when processes enter a non-global zone, their core file path and
  60  * content are set to the zone's default path and content.
  61  *
  62  * Processes that have their core file settings explicitly overridden using
  63  * coreadm(1M) no longer reference core_default_path or core_default_content
  64  * so subsequent changes to the default will not affect them.
  65  */
  66
  67 zone_key_t      core_zone_key;
  68
  69 static int set_proc_info(pid_t pid, const char *path, core_content_t content);
  70
  71 static corectl_content_t *
  72 corectl_content_alloc(core_content_t cc)
  73 {
  74         corectl_content_t *ccp;
  75
  76         ccp = kmem_zalloc(sizeof (corectl_content_t), KM_SLEEP);
  77         ccp->ccc_content = cc;
  78         ccp->ccc_refcnt = 1;
  79
  80         return (ccp);
  81 }
  82
  83 core_content_t
  84 corectl_content_value(corectl_content_t *ccp)
  85 {
  86         core_content_t content;
  87
  88         mutex_enter(&ccp->ccc_mtx);
  89         content = ccp->ccc_content;
  90         mutex_exit(&ccp->ccc_mtx);
  91
  92         return (content);
  93 }
  94
  95 static void
  96 corectl_content_set(corectl_content_t *ccp, core_content_t content)
  97 {
  98         mutex_enter(&ccp->ccc_mtx);
  99         ccp->ccc_content = content;
 100         mutex_exit(&ccp->ccc_mtx);
 101 }
 102
 103 void
 104 corectl_content_hold(corectl_content_t *ccp)
 105 {
 106         atomic_inc_32(&ccp->ccc_refcnt);
 107 }
 108
 109 void
 110 corectl_content_rele(corectl_content_t *ccp)
 111 {
 112         if (atomic_dec_32_nv(&ccp->ccc_refcnt) == 0)
 113                 kmem_free(ccp, sizeof (corectl_content_t));
 114 }
 115
 116
 117 static corectl_path_t *
 118 corectl_path_alloc(const char *path)
 119 {
 120         corectl_path_t *ccp;
 121
 122         ccp = kmem_zalloc(sizeof (corectl_path_t), KM_SLEEP);
 123         ccp->ccp_path = refstr_alloc(path);
 124         ccp->ccp_refcnt = 1;
 125
 126         return (ccp);
 127 }
 128
 129 refstr_t *
 130 corectl_path_value(corectl_path_t *ccp)
 131 {
 132         refstr_t *path;
 133
 134         mutex_enter(&ccp->ccp_mtx);
 135         refstr_hold(path = ccp->ccp_path);
 136         mutex_exit(&ccp->ccp_mtx);
 137
 138         return (path);
 139 }
 140
 141 static void
 142 corectl_path_set(corectl_path_t *ccp, const char *path)
 143 {
 144         refstr_t *npath = refstr_alloc(path);
 145
 146         mutex_enter(&ccp->ccp_mtx);
 147         refstr_rele(ccp->ccp_path);
 148         ccp->ccp_path = npath;
 149         mutex_exit(&ccp->ccp_mtx);
 150 }
 151
 152 void
 153 corectl_path_hold(corectl_path_t *ccp)
 154 {
 155         atomic_inc_32(&ccp->ccp_refcnt);
 156 }
 157
 158 void
 159 corectl_path_rele(corectl_path_t *ccp)
 160 {
 161         if (atomic_dec_32_nv(&ccp->ccp_refcnt) == 0) {
 162                 refstr_rele(ccp->ccp_path);
 163                 kmem_free(ccp, sizeof (corectl_path_t));
 164         }
 165 }
 166
 167 /*
 168  * Constructor routine to be called when a zone is created.
 169  */
 170 /*ARGSUSED*/
 171 static void *
 172 core_init_zone(zoneid_t zoneid)
 173 {
 174         struct core_globals *cg;
 175
 176         cg = kmem_alloc(sizeof (*cg), KM_SLEEP);
 177         mutex_init(&cg->core_lock, NULL, MUTEX_DEFAULT, NULL);
 178         cg->core_file = NULL;
 179         cg->core_options = CC_PROCESS_PATH;
 180         cg->core_content = CC_CONTENT_DEFAULT;
 181         cg->core_rlimit = RLIM64_INFINITY;
 182         cg->core_default_path = corectl_path_alloc("core");
 183         cg->core_default_content = corectl_content_alloc(CC_CONTENT_DEFAULT);
 184
 185         return (cg);
 186 }
 187
 188 /*
 189  * Destructor routine to be called when a zone is destroyed.
 190  */
 191 /*ARGSUSED*/
 192 static void
 193 core_free_zone(zoneid_t zoneid, void *arg)
 194 {
 195         struct core_globals *cg = arg;
 196
 197         if (cg == NULL)
 198                 return;
 199         if (cg->core_file != NULL)
 200                 refstr_rele(cg->core_file);
 201         corectl_path_rele(cg->core_default_path);
 202         corectl_content_rele(cg->core_default_content);
 203         kmem_free(cg, sizeof (*cg));
 204 }
 205
 206 /*
 207  * Called from start_init_common(), to set init's core file path and content.
 208  */
 209 void
 210 init_core(void)
 211 {
 212         struct core_globals *cg;
 213
 214         /*
 215          * The first time we hit this, in the global zone, we have to
 216          * initialize the zsd key.
 217          */
 218         if (INGLOBALZONE(curproc)) {
 219                 zone_key_create(&core_zone_key, core_init_zone, NULL,
 220                     core_free_zone);
 221         }
 222
 223         /*
 224          * zone_key_create will have called core_init_zone for the
 225          * global zone, which sets up the default path and content
 226          * variables.
 227          */
 228         VERIFY((cg = zone_getspecific(core_zone_key, curproc->p_zone)) != NULL);
 229
 230         corectl_path_hold(cg->core_default_path);
 231         corectl_content_hold(cg->core_default_content);
 232
 233         curproc->p_corefile = cg->core_default_path;
 234         curproc->p_content = cg->core_default_content;
 235 }
 236
 237 int
 238 corectl(int subcode, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3)
 239 {
 240         int error = 0;
 241         proc_t *p;
 242         refstr_t *rp;
 243         size_t size;
 244         char *path;
 245         core_content_t content = CC_CONTENT_INVALID;
 246         struct core_globals *cg;
 247         zone_t *zone = curproc->p_zone;
 248
 249         cg = zone_getspecific(core_zone_key, zone);
 250         ASSERT(cg != NULL);
 251
 252         switch (subcode) {
 253         case CC_SET_OPTIONS:
 254                 if ((error = secpolicy_coreadm(CRED())) == 0) {
 255                         if (arg1 & ~CC_OPTIONS)
 256                                 error = EINVAL;
 257                         else
 258                                 cg->core_options = (uint32_t)arg1;
 259                 }
 260                 break;
 261
 262         case CC_GET_OPTIONS:
 263                 return (cg->core_options);
 264
 265         case CC_GET_GLOBAL_PATH:
 266         case CC_GET_DEFAULT_PATH:
 267         case CC_GET_PROCESS_PATH:
 268                 if (subcode == CC_GET_GLOBAL_PATH) {
 269                         mutex_enter(&cg->core_lock);
 270                         if ((rp = cg->core_file) != NULL)
 271                                 refstr_hold(rp);
 272                         mutex_exit(&cg->core_lock);
 273                 } else if (subcode == CC_GET_DEFAULT_PATH) {
 274                         rp = corectl_path_value(cg->core_default_path);
 275                 } else {
 276                         rp = NULL;
 277                         mutex_enter(&pidlock);
 278                         if ((p = prfind((pid_t)arg3)) == NULL ||
 279                             p->p_stat == SIDL) {
 280                                 mutex_exit(&pidlock);
 281                                 error = ESRCH;
 282                         } else {
 283                                 mutex_enter(&p->p_lock);
 284                                 mutex_exit(&pidlock);
 285                                 mutex_enter(&p->p_crlock);
 286                                 if (!hasprocperm(p->p_cred, CRED()))
 287                                         error = EPERM;
 288                                 else if (p->p_corefile != NULL)
 289                                         rp = corectl_path_value(p->p_corefile);
 290                                 mutex_exit(&p->p_crlock);
 291                                 mutex_exit(&p->p_lock);
 292                         }
 293                 }
 294                 if (rp == NULL) {
 295                         if (error == 0 && suword8((void *)arg1, 0))
 296                                 error = EFAULT;
 297                 } else {
 298                         error = copyoutstr(refstr_value(rp), (char *)arg1,
 299                             (size_t)arg2, NULL);
 300                         refstr_rele(rp);
 301                 }
 302                 break;
 303
 304         case CC_SET_GLOBAL_PATH:
 305         case CC_SET_DEFAULT_PATH:
 306                 if ((error = secpolicy_coreadm(CRED())) != 0)
 307                         break;
 308
 309                 /* FALLTHROUGH */
 310         case CC_SET_PROCESS_PATH:
 311                 if ((size = MIN((size_t)arg2, MAXPATHLEN)) == 0) {
 312                         error = EINVAL;
 313                         break;
 314                 }
 315                 path = kmem_alloc(size, KM_SLEEP);
 316                 error = copyinstr((char *)arg1, path, size, NULL);
 317                 if (error == 0) {
 318                         if (subcode == CC_SET_PROCESS_PATH) {
 319                                 error = set_proc_info((pid_t)arg3, path, 0);
 320                         } else if (subcode == CC_SET_DEFAULT_PATH) {
 321                                 corectl_path_set(cg->core_default_path, path);
 322                         } else if (*path != '\0' && *path != '/') {
 323                                 error = EINVAL;
 324                         } else {
 325                                 refstr_t *nrp = refstr_alloc(path);
 326
 327                                 mutex_enter(&cg->core_lock);
 328                                 rp = cg->core_file;
 329                                 if (*path == '\0')
 330                                         cg->core_file = NULL;
 331                                 else
 332                                         refstr_hold(cg->core_file = nrp);
 333                                 mutex_exit(&cg->core_lock);
 334
 335                                 if (rp != NULL)
 336                                         refstr_rele(rp);
 337
 338                                 refstr_rele(nrp);
 339                         }
 340                 }
 341                 kmem_free(path, size);
 342                 break;
 343
 344         case CC_SET_GLOBAL_CONTENT:
 345         case CC_SET_DEFAULT_CONTENT:
 346                 if ((error = secpolicy_coreadm(CRED())) != 0)
 347                         break;
 348
 349                 /* FALLTHROUGH */
 350         case CC_SET_PROCESS_CONTENT:
 351                 error = copyin((void *)arg1, &content, sizeof (content));
 352                 if (error != 0)
 353                         break;
 354
 355                 /*
 356                  * If any unknown bits are set, don't let this charade
 357                  * continue.
 358                  */
 359                 if (content & ~CC_CONTENT_ALL) {
 360                         error = EINVAL;
 361                         break;
 362                 }
 363
 364                 if (subcode == CC_SET_PROCESS_CONTENT) {
 365                         error = set_proc_info((pid_t)arg2, NULL, content);
 366                 } else if (subcode == CC_SET_DEFAULT_CONTENT) {
 367                         corectl_content_set(cg->core_default_content, content);
 368                 } else {
 369                         mutex_enter(&cg->core_lock);
 370                         cg->core_content = content;
 371                         mutex_exit(&cg->core_lock);
 372                 }
 373
 374                 break;
 375
 376         case CC_GET_GLOBAL_CONTENT:
 377                 content = cg->core_content;
 378                 error = copyout(&content, (void *)arg1, sizeof (content));
 379                 break;
 380
 381         case CC_GET_DEFAULT_CONTENT:
 382                 content = corectl_content_value(cg->core_default_content);
 383                 error = copyout(&content, (void *)arg1, sizeof (content));
 384                 break;
 385
 386         case CC_GET_PROCESS_CONTENT:
 387                 mutex_enter(&pidlock);
 388                 if ((p = prfind((pid_t)arg2)) == NULL || p->p_stat == SIDL) {
 389                         mutex_exit(&pidlock);
 390                         error = ESRCH;
 391                         break;
 392                 }
 393
 394                 mutex_enter(&p->p_lock);
 395                 mutex_exit(&pidlock);
 396                 mutex_enter(&p->p_crlock);
 397                 if (!hasprocperm(p->p_cred, CRED()))
 398                         error = EPERM;
 399                 else if (p->p_content == NULL)
 400                         content = CC_CONTENT_NONE;
 401                 else
 402                         content = corectl_content_value(p->p_content);
 403                 mutex_exit(&p->p_crlock);
 404                 mutex_exit(&p->p_lock);
 405
 406                 if (error == 0)
 407                         error = copyout(&content, (void *)arg1,
 408                             sizeof (content));
 409                 break;
 410
 411         default:
 412                 error = EINVAL;
 413                 break;
 414         }
 415
 416         if (error)
 417                 return (set_errno(error));
 418         return (0);
 419 }
 420
 421 typedef struct {
 422         int                     cc_count;
 423         corectl_path_t          *cc_path;
 424         corectl_content_t       *cc_content;
 425 } counter_t;
 426
 427 static int
 428 set_one_proc_info(proc_t *p, counter_t *counterp)
 429 {
 430         corectl_path_t *corefile;
 431         corectl_content_t *content;
 432
 433         mutex_enter(&p->p_crlock);
 434
 435         if (!(p->p_flag & SSYS) && hasprocperm(p->p_cred, CRED())) {
 436                 mutex_exit(&p->p_crlock);
 437                 counterp->cc_count++;
 438                 if (counterp->cc_path != NULL) {
 439                         corectl_path_hold(counterp->cc_path);
 440                         mutex_enter(&p->p_lock);
 441                         corefile = p->p_corefile;
 442                         p->p_corefile = counterp->cc_path;
 443                         mutex_exit(&p->p_lock);
 444                         if (corefile != NULL)
 445                                 corectl_path_rele(corefile);
 446                 } else {
 447                         corectl_content_hold(counterp->cc_content);
 448                         mutex_enter(&p->p_lock);
 449                         content = p->p_content;
 450                         p->p_content = counterp->cc_content;
 451                         mutex_exit(&p->p_lock);
 452                         if (content != NULL)
 453                                 corectl_content_rele(content);
 454                 }
 455         } else {
 456                 mutex_exit(&p->p_crlock);
 457         }
 458
 459         return (0);
 460 }
 461
 462 static int
 463 set_proc_info(pid_t pid, const char *path, core_content_t content)
 464 {
 465         proc_t *p;
 466         counter_t counter;
 467         int error = 0;
 468
 469         counter.cc_count = 0;
 470         /*
 471          * Only one of the core file path or content can be set at a time.
 472          */
 473         if (path != NULL) {
 474                 counter.cc_path = corectl_path_alloc(path);
 475                 counter.cc_content = NULL;
 476         } else {
 477                 counter.cc_path = NULL;
 478                 counter.cc_content = corectl_content_alloc(content);
 479         }
 480
 481         if (pid == -1) {
 482                 procset_t set;
 483
 484                 setprocset(&set, POP_AND, P_ALL, P_MYID, P_ALL, P_MYID);
 485                 error = dotoprocs(&set, set_one_proc_info, (char *)&counter);
 486                 if (error == 0 && counter.cc_count == 0)
 487                         error = EPERM;
 488         } else if (pid > 0) {
 489                 mutex_enter(&pidlock);
 490                 if ((p = prfind(pid)) == NULL || p->p_stat == SIDL) {
 491                         error = ESRCH;
 492                 } else {
 493                         (void) set_one_proc_info(p, &counter);
 494                         if (counter.cc_count == 0)
 495                                 error = EPERM;
 496                 }
 497                 mutex_exit(&pidlock);
 498         } else {
 499                 int nfound = 0;
 500                 pid_t pgid;
 501
 502                 if (pid == 0)
 503                         pgid = curproc->p_pgrp;
 504                 else
 505                         pgid = -pid;
 506
 507                 mutex_enter(&pidlock);
 508                 for (p = pgfind(pgid); p != NULL; p = p->p_pglink) {
 509                         if (p->p_stat != SIDL) {
 510                                 nfound++;
 511                                 (void) set_one_proc_info(p, &counter);
 512                         }
 513                 }
 514                 mutex_exit(&pidlock);
 515                 if (nfound == 0)
 516                         error = ESRCH;
 517                 else if (counter.cc_count == 0)
 518                         error = EPERM;
 519         }
 520
 521         if (path != NULL)
 522                 corectl_path_rele(counter.cc_path);
 523         else
 524                 corectl_content_rele(counter.cc_content);
 525
 526         if (error)
 527                 return (set_errno(error));
 528         return (0);
 529 }
 530
 531 /*
 532  * Give current process the default core settings for its current zone;
 533  * used for processes entering a zone via zone_enter.
 534  */
 535 void
 536 set_core_defaults(void)
 537 {
 538         proc_t *p = curproc;
 539         struct core_globals *cg;
 540         corectl_path_t *oldpath, *newpath;
 541         corectl_content_t *oldcontent, *newcontent;
 542
 543         cg = zone_getspecific(core_zone_key, p->p_zone);
 544
 545         /* make local copies of default values to protect against change */
 546         newpath = cg->core_default_path;
 547         newcontent = cg->core_default_content;
 548
 549         corectl_path_hold(newpath);
 550         corectl_content_hold(newcontent);
 551         mutex_enter(&p->p_lock);
 552         oldpath = p->p_corefile;
 553         p->p_corefile = newpath;
 554         oldcontent = p->p_content;
 555         p->p_content = newcontent;
 556         mutex_exit(&p->p_lock);
 557         if (oldpath != NULL)
 558                 corectl_path_rele(oldpath);
 559         if (oldcontent != NULL)
 560                 corectl_content_rele(oldcontent);
 561 }