sys/kern/kern_resource.c

   1 /*-
   2  * Copyright (c) 1982, 1986, 1991, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  * (c) UNIX System Laboratories, Inc.
   5  * All or some portions of this file are derived from material licensed
   6  * to the University of California by American Telephone and Telegraph
   7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   8  * the permission of UNIX System Laboratories, Inc.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *      This product includes software developed by the University of
  21  *      California, Berkeley and its contributors.
  22  * 4. Neither the name of the University nor the names of its contributors
  23  *    may be used to endorse or promote products derived from this software
  24  *    without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36  * SUCH DAMAGE.
  37  *
  38  *      @(#)kern_resource.c     8.5 (Berkeley) 1/21/94
  39  * $FreeBSD: src/sys/kern/kern_resource.c,v 1.55.2.5 2001/11/03 01:41:08 ps Exp $
  40  * $DragonFly: src/sys/kern/kern_resource.c,v 1.35 2008/05/27 05:25:34 dillon Exp $
  41  */
  42
  43 #include "opt_compat.h"
  44
  45 #include <sys/param.h>
  46 #include <sys/systm.h>
  47 #include <sys/sysproto.h>
  48 #include <sys/file.h>
  49 #include <sys/kern_syscall.h>
  50 #include <sys/kernel.h>
  51 #include <sys/resourcevar.h>
  52 #include <sys/malloc.h>
  53 #include <sys/proc.h>
  54 #include <sys/priv.h>
  55 #include <sys/time.h>
  56 #include <sys/lockf.h>
  57
  58 #include <vm/vm.h>
  59 #include <vm/vm_param.h>
  60 #include <sys/lock.h>
  61 #include <vm/pmap.h>
  62 #include <vm/vm_map.h>
  63
  64 #include <sys/thread2.h>
  65 #include <sys/spinlock2.h>
  66
  67 static int donice (struct proc *chgp, int n);
  68 static int doionice (struct proc *chgp, int n);
  69
  70 static MALLOC_DEFINE(M_UIDINFO, "uidinfo", "uidinfo structures");
  71 #define UIHASH(uid)     (&uihashtbl[(uid) & uihash])
  72 static struct spinlock uihash_lock;
  73 static LIST_HEAD(uihashhead, uidinfo) *uihashtbl;
  74 static u_long uihash;           /* size of hash table - 1 */
  75
  76 static struct uidinfo   *uicreate (uid_t uid);
  77 static struct uidinfo   *uilookup (uid_t uid);
  78
  79 /*
  80  * Resource controls and accounting.
  81  */
  82
  83 struct getpriority_info {
  84         int low;
  85         int who;
  86 };
  87
  88 static int getpriority_callback(struct proc *p, void *data);
  89
  90 /*
  91  * MPALMOSTSAFE
  92  */
  93 int
  94 sys_getpriority(struct getpriority_args *uap)
  95 {
  96         struct getpriority_info info;
  97         struct proc *curp = curproc;
  98         struct proc *p;
  99         int low = PRIO_MAX + 1;
 100         int error;
 101
 102         switch (uap->which) {
 103         case PRIO_PROCESS:
 104                 if (uap->who == 0) {
 105                         p = curp;
 106                         PHOLD(p);
 107                 } else {
 108                         p = pfind(uap->who);
 109                 }
 110                 if (p) {
 111                         if (PRISON_CHECK(curp->p_ucred, p->p_ucred)) {
 112                                 low = p->p_nice;
 113                         }
 114                         PRELE(p);
 115                 }
 116                 break;
 117
 118         case PRIO_PGRP:
 119         {
 120                 struct pgrp *pg;
 121
 122                 if (uap->who == 0) {
 123                         pg = curp->p_pgrp;
 124                         pgref(pg);
 125                 } else if ((pg = pgfind(uap->who)) == NULL) {
 126                         break;
 127                 } /* else ref held from pgfind */
 128
 129                 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
 130                         if (PRISON_CHECK(curp->p_ucred, p->p_ucred) &&
 131                             p->p_nice < low) {
 132                                 low = p->p_nice;
 133                         }
 134                 }
 135                 pgrel(pg);
 136                 break;
 137         }
 138         case PRIO_USER:
 139                 if (uap->who == 0)
 140                         uap->who = curp->p_ucred->cr_uid;
 141                 info.low = low;
 142                 info.who = uap->who;
 143                 allproc_scan(getpriority_callback, &info);
 144                 low = info.low;
 145                 break;
 146
 147         default:
 148                 error = EINVAL;
 149                 goto done;
 150         }
 151         if (low == PRIO_MAX + 1) {
 152                 error = ESRCH;
 153                 goto done;
 154         }
 155         uap->sysmsg_result = low;
 156         error = 0;
 157 done:
 158         return (error);
 159 }
 160
 161 /*
 162  * Figure out the current lowest nice priority for processes owned
 163  * by the specified user.
 164  */
 165 static
 166 int
 167 getpriority_callback(struct proc *p, void *data)
 168 {
 169         struct getpriority_info *info = data;
 170
 171         if (PRISON_CHECK(curproc->p_ucred, p->p_ucred) &&
 172             p->p_ucred->cr_uid == info->who &&
 173             p->p_nice < info->low) {
 174                 info->low = p->p_nice;
 175         }
 176         return(0);
 177 }
 178
 179 struct setpriority_info {
 180         int prio;
 181         int who;
 182         int error;
 183         int found;
 184 };
 185
 186 static int setpriority_callback(struct proc *p, void *data);
 187
 188 /*
 189  * MPALMOSTSAFE
 190  */
 191 int
 192 sys_setpriority(struct setpriority_args *uap)
 193 {
 194         struct setpriority_info info;
 195         struct proc *curp = curproc;
 196         struct proc *p;
 197         int found = 0, error = 0;
 198
 199         lwkt_gettoken(&proc_token);
 200
 201         switch (uap->which) {
 202         case PRIO_PROCESS:
 203                 if (uap->who == 0) {
 204                         p = curp;
 205                         PHOLD(p);
 206                 } else {
 207                         p = pfind(uap->who);
 208                 }
 209                 if (p) {
 210                         if (PRISON_CHECK(curp->p_ucred, p->p_ucred)) {
 211                                 error = donice(p, uap->prio);
 212                                 found++;
 213                         }
 214                         PRELE(p);
 215                 }
 216                 break;
 217
 218         case PRIO_PGRP:
 219         {
 220                 struct pgrp *pg;
 221
 222                 if (uap->who == 0) {
 223                         pg = curp->p_pgrp;
 224                         pgref(pg);
 225                 } else if ((pg = pgfind(uap->who)) == NULL) {
 226                         break;
 227                 } /* else ref held from pgfind */
 228
 229                 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
 230                         if (PRISON_CHECK(curp->p_ucred, p->p_ucred)) {
 231                                 error = donice(p, uap->prio);
 232                                 found++;
 233                         }
 234                 }
 235                 pgrel(pg);
 236                 break;
 237         }
 238         case PRIO_USER:
 239                 if (uap->who == 0)
 240                         uap->who = curp->p_ucred->cr_uid;
 241                 info.prio = uap->prio;
 242                 info.who = uap->who;
 243                 info.error = 0;
 244                 info.found = 0;
 245                 allproc_scan(setpriority_callback, &info);
 246                 error = info.error;
 247                 found = info.found;
 248                 break;
 249
 250         default:
 251                 error = EINVAL;
 252                 found = 1;
 253                 break;
 254         }
 255
 256         lwkt_reltoken(&proc_token);
 257
 258         if (found == 0)
 259                 error = ESRCH;
 260         return (error);
 261 }
 262
 263 static
 264 int
 265 setpriority_callback(struct proc *p, void *data)
 266 {
 267         struct setpriority_info *info = data;
 268         int error;
 269
 270         if (p->p_ucred->cr_uid == info->who &&
 271             PRISON_CHECK(curproc->p_ucred, p->p_ucred)) {
 272                 error = donice(p, info->prio);
 273                 if (error)
 274                         info->error = error;
 275                 ++info->found;
 276         }
 277         return(0);
 278 }
 279
 280 static int
 281 donice(struct proc *chgp, int n)
 282 {
 283         struct proc *curp = curproc;
 284         struct ucred *cr = curp->p_ucred;
 285         struct lwp *lp;
 286
 287         if (cr->cr_uid && cr->cr_ruid &&
 288             cr->cr_uid != chgp->p_ucred->cr_uid &&
 289             cr->cr_ruid != chgp->p_ucred->cr_uid)
 290                 return (EPERM);
 291         if (n > PRIO_MAX)
 292                 n = PRIO_MAX;
 293         if (n < PRIO_MIN)
 294                 n = PRIO_MIN;
 295         if (n < chgp->p_nice && priv_check_cred(cr, PRIV_SCHED_SETPRIORITY, 0))
 296                 return (EACCES);
 297         chgp->p_nice = n;
 298         FOREACH_LWP_IN_PROC(lp, chgp) {
 299                 LWPHOLD(lp);
 300                 chgp->p_usched->resetpriority(lp);
 301                 LWPRELE(lp);
 302         }
 303         return (0);
 304 }
 305
 306
 307 struct ioprio_get_info {
 308         int high;
 309         int who;
 310 };
 311
 312 static int ioprio_get_callback(struct proc *p, void *data);
 313
 314 /*
 315  * MPALMOSTSAFE
 316  */
 317 int
 318 sys_ioprio_get(struct ioprio_get_args *uap)
 319 {
 320         struct ioprio_get_info info;
 321         struct proc *curp = curproc;
 322         struct proc *p;
 323         int high = IOPRIO_MIN-2;
 324         int error;
 325
 326         lwkt_gettoken(&proc_token);
 327
 328         switch (uap->which) {
 329         case PRIO_PROCESS:
 330                 if (uap->who == 0) {
 331                         p = curp;
 332                         PHOLD(p);
 333                 } else {
 334                         p = pfind(uap->who);
 335                 }
 336                 if (p) {
 337                         if (PRISON_CHECK(curp->p_ucred, p->p_ucred))
 338                                 high = p->p_ionice;
 339                         PRELE(p);
 340                 }
 341                 break;
 342
 343         case PRIO_PGRP:
 344         {
 345                 struct pgrp *pg;
 346
 347                 if (uap->who == 0) {
 348                         pg = curp->p_pgrp;
 349                         pgref(pg);
 350                 } else if ((pg = pgfind(uap->who)) == NULL) {
 351                         break;
 352                 } /* else ref held from pgfind */
 353
 354                 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
 355                         if (PRISON_CHECK(curp->p_ucred, p->p_ucred) &&
 356                             p->p_nice > high)
 357                                 high = p->p_ionice;
 358                 }
 359                 pgrel(pg);
 360                 break;
 361         }
 362         case PRIO_USER:
 363                 if (uap->who == 0)
 364                         uap->who = curp->p_ucred->cr_uid;
 365                 info.high = high;
 366                 info.who = uap->who;
 367                 allproc_scan(ioprio_get_callback, &info);
 368                 high = info.high;
 369                 break;
 370
 371         default:
 372                 error = EINVAL;
 373                 goto done;
 374         }
 375         if (high == IOPRIO_MIN-2) {
 376                 error = ESRCH;
 377                 goto done;
 378         }
 379         uap->sysmsg_result = high;
 380         error = 0;
 381 done:
 382         lwkt_reltoken(&proc_token);
 383
 384         return (error);
 385 }
 386
 387 /*
 388  * Figure out the current lowest nice priority for processes owned
 389  * by the specified user.
 390  */
 391 static
 392 int
 393 ioprio_get_callback(struct proc *p, void *data)
 394 {
 395         struct ioprio_get_info *info = data;
 396
 397         if (PRISON_CHECK(curproc->p_ucred, p->p_ucred) &&
 398             p->p_ucred->cr_uid == info->who &&
 399             p->p_ionice > info->high) {
 400                 info->high = p->p_ionice;
 401         }
 402         return(0);
 403 }
 404
 405
 406 struct ioprio_set_info {
 407         int prio;
 408         int who;
 409         int error;
 410         int found;
 411 };
 412
 413 static int ioprio_set_callback(struct proc *p, void *data);
 414
 415 /*
 416  * MPALMOSTSAFE
 417  */
 418 int
 419 sys_ioprio_set(struct ioprio_set_args *uap)
 420 {
 421         struct ioprio_set_info info;
 422         struct proc *curp = curproc;
 423         struct proc *p;
 424         int found = 0, error = 0;
 425
 426         lwkt_gettoken(&proc_token);
 427
 428         switch (uap->which) {
 429         case PRIO_PROCESS:
 430                 if (uap->who == 0) {
 431                         p = curp;
 432                         PHOLD(p);
 433                 } else {
 434                         p = pfind(uap->who);
 435                 }
 436                 if (p) {
 437                         if (PRISON_CHECK(curp->p_ucred, p->p_ucred)) {
 438                                 error = doionice(p, uap->prio);
 439                                 found++;
 440                         }
 441                         PRELE(p);
 442                 }
 443                 break;
 444
 445         case PRIO_PGRP:
 446         {
 447                 struct pgrp *pg;
 448
 449                 if (uap->who == 0) {
 450                         pg = curp->p_pgrp;
 451                         pgref(pg);
 452                 } else if ((pg = pgfind(uap->who)) == NULL) {
 453                         break;
 454                 } /* else ref held from pgfind */
 455
 456                 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
 457                         if (PRISON_CHECK(curp->p_ucred, p->p_ucred)) {
 458                                 error = doionice(p, uap->prio);
 459                                 found++;
 460                         }
 461                 }
 462                 pgrel(pg);
 463                 break;
 464         }
 465         case PRIO_USER:
 466                 if (uap->who == 0)
 467                         uap->who = curp->p_ucred->cr_uid;
 468                 info.prio = uap->prio;
 469                 info.who = uap->who;
 470                 info.error = 0;
 471                 info.found = 0;
 472                 allproc_scan(ioprio_set_callback, &info);
 473                 error = info.error;
 474                 found = info.found;
 475                 break;
 476
 477         default:
 478                 error = EINVAL;
 479                 found = 1;
 480                 break;
 481         }
 482
 483         lwkt_reltoken(&proc_token);
 484
 485         if (found == 0)
 486                 error = ESRCH;
 487         return (error);
 488 }
 489
 490 static
 491 int
 492 ioprio_set_callback(struct proc *p, void *data)
 493 {
 494         struct ioprio_set_info *info = data;
 495         int error;
 496
 497         if (p->p_ucred->cr_uid == info->who &&
 498             PRISON_CHECK(curproc->p_ucred, p->p_ucred)) {
 499                 error = doionice(p, info->prio);
 500                 if (error)
 501                         info->error = error;
 502                 ++info->found;
 503         }
 504         return(0);
 505 }
 506
 507 int
 508 doionice(struct proc *chgp, int n)
 509 {
 510         struct proc *curp = curproc;
 511         struct ucred *cr = curp->p_ucred;
 512
 513         if (cr->cr_uid && cr->cr_ruid &&
 514             cr->cr_uid != chgp->p_ucred->cr_uid &&
 515             cr->cr_ruid != chgp->p_ucred->cr_uid)
 516                 return (EPERM);
 517         if (n > IOPRIO_MAX)
 518                 n = IOPRIO_MAX;
 519         if (n < IOPRIO_MIN)
 520                 n = IOPRIO_MIN;
 521         if (n < chgp->p_ionice && priv_check_cred(cr, PRIV_SCHED_SETPRIORITY, 0))
 522                 return (EACCES);
 523         chgp->p_ionice = n;
 524
 525         return (0);
 526
 527 }
 528
 529 /*
 530  * MPALMOSTSAFE
 531  */
 532 int
 533 sys_lwp_rtprio(struct lwp_rtprio_args *uap)
 534 {
 535         struct proc *p;
 536         struct lwp *lp;
 537         struct rtprio rtp;
 538         struct ucred *cr = curthread->td_ucred;
 539         int error;
 540
 541         error = copyin(uap->rtp, &rtp, sizeof(struct rtprio));
 542         if (error)
 543                 return error;
 544         if (uap->pid < 0)
 545                 return EINVAL;
 546
 547         lwkt_gettoken(&proc_token);
 548
 549         if (uap->pid == 0) {
 550                 p = curproc;
 551                 PHOLD(p);
 552         } else {
 553                 p = pfind(uap->pid);
 554         }
 555
 556         if (p == NULL) {
 557                 error = ESRCH;
 558                 goto done;
 559         }
 560
 561         if (uap->tid < -1) {
 562                 error = EINVAL;
 563                 goto done;
 564         }
 565         if (uap->tid == -1) {
 566                 /*
 567                  * sadly, tid can be 0 so we can't use 0 here
 568                  * like sys_rtprio()
 569                  */
 570                 lp = curthread->td_lwp;
 571         } else {
 572                 lp = lwp_rb_tree_RB_LOOKUP(&p->p_lwp_tree, uap->tid);
 573                 if (lp == NULL) {
 574                         error = ESRCH;
 575                         goto done;
 576                 }
 577         }
 578
 579         switch (uap->function) {
 580         case RTP_LOOKUP:
 581                 error = copyout(&lp->lwp_rtprio, uap->rtp,
 582                                 sizeof(struct rtprio));
 583                 break;
 584         case RTP_SET:
 585                 if (cr->cr_uid && cr->cr_ruid &&
 586                     cr->cr_uid != p->p_ucred->cr_uid &&
 587                     cr->cr_ruid != p->p_ucred->cr_uid) {
 588                         error = EPERM;
 589                         break;
 590                 }
 591                 /* disallow setting rtprio in most cases if not superuser */
 592                 if (priv_check_cred(cr, PRIV_SCHED_RTPRIO, 0)) {
 593                         /* can't set someone else's */
 594                         if (uap->pid) { /* XXX */
 595                                 error = EPERM;
 596                                 break;
 597                         }
 598                         /* can't set realtime priority */
 599 /*
 600  * Realtime priority has to be restricted for reasons which should be
 601  * obvious. However, for idle priority, there is a potential for
 602  * system deadlock if an idleprio process gains a lock on a resource
 603  * that other processes need (and the idleprio process can't run
 604  * due to a CPU-bound normal process). Fix me! XXX
 605  */
 606                         if (RTP_PRIO_IS_REALTIME(rtp.type)) {
 607                                 error = EPERM;
 608                                 break;
 609                         }
 610                 }
 611                 switch (rtp.type) {
 612 #ifdef RTP_PRIO_FIFO
 613                 case RTP_PRIO_FIFO:
 614 #endif
 615                 case RTP_PRIO_REALTIME:
 616                 case RTP_PRIO_NORMAL:
 617                 case RTP_PRIO_IDLE:
 618                         if (rtp.prio > RTP_PRIO_MAX) {
 619                                 error = EINVAL;
 620                         } else {
 621                                 lp->lwp_rtprio = rtp;
 622                                 error = 0;
 623                         }
 624                         break;
 625                 default:
 626                         error = EINVAL;
 627                         break;
 628                 }
 629                 break;
 630         default:
 631                 error = EINVAL;
 632                 break;
 633         }
 634
 635 done:
 636         if (p)
 637                 PRELE(p);
 638         lwkt_reltoken(&proc_token);
 639
 640         return (error);
 641 }
 642
 643 /*
 644  * Set realtime priority
 645  *
 646  * MPALMOSTSAFE
 647  */
 648 int
 649 sys_rtprio(struct rtprio_args *uap)
 650 {
 651         struct proc *p;
 652         struct lwp *lp;
 653         struct ucred *cr = curthread->td_ucred;
 654         struct rtprio rtp;
 655         int error;
 656
 657         error = copyin(uap->rtp, &rtp, sizeof(struct rtprio));
 658         if (error)
 659                 return (error);
 660
 661         lwkt_gettoken(&proc_token);
 662
 663         if (uap->pid == 0) {
 664                 p = curproc;
 665                 PHOLD(p);
 666         } else {
 667                 p = pfind(uap->pid);
 668         }
 669
 670         if (p == NULL) {
 671                 error = ESRCH;
 672                 goto done;
 673         }
 674
 675         /* XXX lwp */
 676         lp = FIRST_LWP_IN_PROC(p);
 677         switch (uap->function) {
 678         case RTP_LOOKUP:
 679                 error = copyout(&lp->lwp_rtprio, uap->rtp,
 680                                 sizeof(struct rtprio));
 681                 break;
 682         case RTP_SET:
 683                 if (cr->cr_uid && cr->cr_ruid &&
 684                     cr->cr_uid != p->p_ucred->cr_uid &&
 685                     cr->cr_ruid != p->p_ucred->cr_uid) {
 686                         error = EPERM;
 687                         break;
 688                 }
 689                 /* disallow setting rtprio in most cases if not superuser */
 690                 if (priv_check_cred(cr, PRIV_SCHED_RTPRIO, 0)) {
 691                         /* can't set someone else's */
 692                         if (uap->pid) {
 693                                 error = EPERM;
 694                                 break;
 695                         }
 696                         /* can't set realtime priority */
 697 /*
 698  * Realtime priority has to be restricted for reasons which should be
 699  * obvious. However, for idle priority, there is a potential for
 700  * system deadlock if an idleprio process gains a lock on a resource
 701  * that other processes need (and the idleprio process can't run
 702  * due to a CPU-bound normal process). Fix me! XXX
 703  */
 704                         if (RTP_PRIO_IS_REALTIME(rtp.type)) {
 705                                 error = EPERM;
 706                                 break;
 707                         }
 708                 }
 709                 switch (rtp.type) {
 710 #ifdef RTP_PRIO_FIFO
 711                 case RTP_PRIO_FIFO:
 712 #endif
 713                 case RTP_PRIO_REALTIME:
 714                 case RTP_PRIO_NORMAL:
 715                 case RTP_PRIO_IDLE:
 716                         if (rtp.prio > RTP_PRIO_MAX) {
 717                                 error = EINVAL;
 718                                 break;
 719                         }
 720                         lp->lwp_rtprio = rtp;
 721                         error = 0;
 722                         break;
 723                 default:
 724                         error = EINVAL;
 725                         break;
 726                 }
 727                 break;
 728         default:
 729                 error = EINVAL;
 730                 break;
 731         }
 732 done:
 733         if (p)
 734                 PRELE(p);
 735         lwkt_reltoken(&proc_token);
 736
 737         return (error);
 738 }
 739
 740 /*
 741  * MPSAFE
 742  */
 743 int
 744 sys_setrlimit(struct __setrlimit_args *uap)
 745 {
 746         struct rlimit alim;
 747         int error;
 748
 749         error = copyin(uap->rlp, &alim, sizeof(alim));
 750         if (error)
 751                 return (error);
 752
 753         error = kern_setrlimit(uap->which, &alim);
 754
 755         return (error);
 756 }
 757
 758 /*
 759  * MPSAFE
 760  */
 761 int
 762 sys_getrlimit(struct __getrlimit_args *uap)
 763 {
 764         struct rlimit lim;
 765         int error;
 766
 767         error = kern_getrlimit(uap->which, &lim);
 768
 769         if (error == 0)
 770                 error = copyout(&lim, uap->rlp, sizeof(*uap->rlp));
 771         return error;
 772 }
 773
 774 /*
 775  * Transform the running time and tick information in lwp lp's thread into user,
 776  * system, and interrupt time usage.
 777  *
 778  * Since we are limited to statclock tick granularity this is a statisical
 779  * calculation which will be correct over the long haul, but should not be
 780  * expected to measure fine grained deltas.
 781  *
 782  * It is possible to catch a lwp in the midst of being created, so
 783  * check whether lwp_thread is NULL or not.
 784  */
 785 void
 786 calcru(struct lwp *lp, struct timeval *up, struct timeval *sp)
 787 {
 788         struct thread *td;
 789
 790         /*
 791          * Calculate at the statclock level.  YYY if the thread is owned by
 792          * another cpu we need to forward the request to the other cpu, or
 793          * have a token to interlock the information in order to avoid racing
 794          * thread destruction.
 795          */
 796         if ((td = lp->lwp_thread) != NULL) {
 797                 crit_enter();
 798                 up->tv_sec = td->td_uticks / 1000000;
 799                 up->tv_usec = td->td_uticks % 1000000;
 800                 sp->tv_sec = td->td_sticks / 1000000;
 801                 sp->tv_usec = td->td_sticks % 1000000;
 802                 crit_exit();
 803         }
 804 }
 805
 806 /*
 807  * Aggregate resource statistics of all lwps of a process.
 808  *
 809  * proc.p_ru keeps track of all statistics directly related to a proc.  This
 810  * consists of RSS usage and nswap information and aggregate numbers for all
 811  * former lwps of this proc.
 812  *
 813  * proc.p_cru is the sum of all stats of reaped children.
 814  *
 815  * lwp.lwp_ru contains the stats directly related to one specific lwp, meaning
 816  * packet, scheduler switch or page fault counts, etc.  This information gets
 817  * added to lwp.lwp_proc.p_ru when the lwp exits.
 818  */
 819 void
 820 calcru_proc(struct proc *p, struct rusage *ru)
 821 {
 822         struct timeval upt, spt;
 823         long *rip1, *rip2;
 824         struct lwp *lp;
 825
 826         *ru = p->p_ru;
 827
 828         FOREACH_LWP_IN_PROC(lp, p) {
 829                 calcru(lp, &upt, &spt);
 830                 timevaladd(&ru->ru_utime, &upt);
 831                 timevaladd(&ru->ru_stime, &spt);
 832                 for (rip1 = &ru->ru_first, rip2 = &lp->lwp_ru.ru_first;
 833                      rip1 <= &ru->ru_last;
 834                      rip1++, rip2++)
 835                         *rip1 += *rip2;
 836         }
 837 }
 838
 839
 840 /*
 841  * MPALMOSTSAFE
 842  */
 843 int
 844 sys_getrusage(struct getrusage_args *uap)
 845 {
 846         struct rusage ru;
 847         struct rusage *rup;
 848         int error;
 849
 850         lwkt_gettoken(&proc_token);
 851
 852         switch (uap->who) {
 853         case RUSAGE_SELF:
 854                 rup = &ru;
 855                 calcru_proc(curproc, rup);
 856                 error = 0;
 857                 break;
 858         case RUSAGE_CHILDREN:
 859                 rup = &curproc->p_cru;
 860                 error = 0;
 861                 break;
 862         default:
 863                 error = EINVAL;
 864                 break;
 865         }
 866         if (error == 0)
 867                 error = copyout(rup, uap->rusage, sizeof(struct rusage));
 868         lwkt_reltoken(&proc_token);
 869         return (error);
 870 }
 871
 872 void
 873 ruadd(struct rusage *ru, struct rusage *ru2)
 874 {
 875         long *ip, *ip2;
 876         int i;
 877
 878         timevaladd(&ru->ru_utime, &ru2->ru_utime);
 879         timevaladd(&ru->ru_stime, &ru2->ru_stime);
 880         if (ru->ru_maxrss < ru2->ru_maxrss)
 881                 ru->ru_maxrss = ru2->ru_maxrss;
 882         ip = &ru->ru_first; ip2 = &ru2->ru_first;
 883         for (i = &ru->ru_last - &ru->ru_first; i >= 0; i--)
 884                 *ip++ += *ip2++;
 885 }
 886
 887 /*
 888  * Find the uidinfo structure for a uid.  This structure is used to
 889  * track the total resource consumption (process count, socket buffer
 890  * size, etc.) for the uid and impose limits.
 891  */
 892 void
 893 uihashinit(void)
 894 {
 895         spin_init(&uihash_lock);
 896         uihashtbl = hashinit(maxproc / 16, M_UIDINFO, &uihash);
 897 }
 898
 899 /*
 900  * NOTE: Must be called with uihash_lock held
 901  *
 902  * MPSAFE
 903  */
 904 static struct uidinfo *
 905 uilookup(uid_t uid)
 906 {
 907         struct  uihashhead *uipp;
 908         struct  uidinfo *uip;
 909
 910         uipp = UIHASH(uid);
 911         LIST_FOREACH(uip, uipp, ui_hash) {
 912                 if (uip->ui_uid == uid)
 913                         break;
 914         }
 915         return (uip);
 916 }
 917
 918 /*
 919  * Helper function to creat ea uid that could not be found.
 920  * This function will properly deal with races.
 921  *
 922  * MPSAFE
 923  */
 924 static struct uidinfo *
 925 uicreate(uid_t uid)
 926 {
 927         struct  uidinfo *uip, *tmp;
 928
 929         /*
 930          * Allocate space and check for a race
 931          */
 932         uip = kmalloc(sizeof(*uip), M_UIDINFO, M_WAITOK|M_ZERO);
 933
 934         /*
 935          * Initialize structure and enter it into the hash table
 936          */
 937         spin_init(&uip->ui_lock);
 938         uip->ui_uid = uid;
 939         uip->ui_ref = 1;        /* we're returning a ref */
 940         varsymset_init(&uip->ui_varsymset, NULL);
 941
 942         /*
 943          * Somebody may have already created the uidinfo for this
 944          * uid. If so, return that instead.
 945          */
 946         spin_lock(&uihash_lock);
 947         tmp = uilookup(uid);
 948         if (tmp != NULL) {
 949                 uihold(tmp);
 950                 spin_unlock(&uihash_lock);
 951
 952                 spin_uninit(&uip->ui_lock);
 953                 varsymset_clean(&uip->ui_varsymset);
 954                 FREE(uip, M_UIDINFO);
 955                 uip = tmp;
 956         } else {
 957                 LIST_INSERT_HEAD(UIHASH(uid), uip, ui_hash);
 958                 spin_unlock(&uihash_lock);
 959         }
 960         return (uip);
 961 }
 962
 963 /*
 964  *
 965  *
 966  * MPSAFE
 967  */
 968 struct uidinfo *
 969 uifind(uid_t uid)
 970 {
 971         struct  uidinfo *uip;
 972
 973         spin_lock(&uihash_lock);
 974         uip = uilookup(uid);
 975         if (uip == NULL) {
 976                 spin_unlock(&uihash_lock);
 977                 uip = uicreate(uid);
 978         } else {
 979                 uihold(uip);
 980                 spin_unlock(&uihash_lock);
 981         }
 982         return (uip);
 983 }
 984
 985 /*
 986  * Helper funtion to remove a uidinfo whos reference count is
 987  * transitioning from 1->0.  The reference count is 1 on call.
 988  *
 989  * Zero is returned on success, otherwise non-zero and the
 990  * uiphas not been removed.
 991  *
 992  * MPSAFE
 993  */
 994 static __inline int
 995 uifree(struct uidinfo *uip)
 996 {
 997         /*
 998          * If we are still the only holder after acquiring the uihash_lock
 999          * we can safely unlink the uip and destroy it.  Otherwise we lost
1000          * a race and must fail.
1001          */
1002         spin_lock(&uihash_lock);
1003         if (uip->ui_ref != 1) {
1004                 spin_unlock(&uihash_lock);
1005                 return(-1);
1006         }
1007         LIST_REMOVE(uip, ui_hash);
1008         spin_unlock(&uihash_lock);
1009
1010         /*
1011          * The uip is now orphaned and we can destroy it at our
1012          * leisure.
1013          */
1014         if (uip->ui_sbsize != 0)
1015                 kprintf("freeing uidinfo: uid = %d, sbsize = %jd\n",
1016                     uip->ui_uid, (intmax_t)uip->ui_sbsize);
1017         if (uip->ui_proccnt != 0)
1018                 kprintf("freeing uidinfo: uid = %d, proccnt = %ld\n",
1019                     uip->ui_uid, uip->ui_proccnt);
1020
1021         varsymset_clean(&uip->ui_varsymset);
1022         lockuninit(&uip->ui_varsymset.vx_lock);
1023         spin_uninit(&uip->ui_lock);
1024         FREE(uip, M_UIDINFO);
1025         return(0);
1026 }
1027
1028 /*
1029  * MPSAFE
1030  */
1031 void
1032 uihold(struct uidinfo *uip)
1033 {
1034         atomic_add_int(&uip->ui_ref, 1);
1035         KKASSERT(uip->ui_ref >= 0);
1036 }
1037
1038 /*
1039  * NOTE: It is important for us to not drop the ref count to 0
1040  *       because this can cause a 2->0/2->0 race with another
1041  *       concurrent dropper.  Losing the race in that situation
1042  *       can cause uip to become stale for one of the other
1043  *       threads.
1044  *
1045  * MPSAFE
1046  */
1047 void
1048 uidrop(struct uidinfo *uip)
1049 {
1050         int ref;
1051
1052         KKASSERT(uip->ui_ref > 0);
1053
1054         for (;;) {
1055                 ref = uip->ui_ref;
1056                 cpu_ccfence();
1057                 if (ref == 1) {
1058                         if (uifree(uip) == 0)
1059                                 break;
1060                 } else if (atomic_cmpset_int(&uip->ui_ref, ref, ref - 1)) {
1061                         break;
1062                 }
1063                 /* else retry */
1064         }
1065 }
1066
1067 void
1068 uireplace(struct uidinfo **puip, struct uidinfo *nuip)
1069 {
1070         uidrop(*puip);
1071         *puip = nuip;
1072 }
1073
1074 /*
1075  * Change the count associated with number of processes
1076  * a given user is using.  When 'max' is 0, don't enforce a limit
1077  */
1078 int
1079 chgproccnt(struct uidinfo *uip, int diff, int max)
1080 {
1081         int ret;
1082         spin_lock(&uip->ui_lock);
1083         /* don't allow them to exceed max, but allow subtraction */
1084         if (diff > 0 && uip->ui_proccnt + diff > max && max != 0) {
1085                 ret = 0;
1086         } else {
1087                 uip->ui_proccnt += diff;
1088                 if (uip->ui_proccnt < 0)
1089                         kprintf("negative proccnt for uid = %d\n", uip->ui_uid);
1090                 ret = 1;
1091         }
1092         spin_unlock(&uip->ui_lock);
1093         return ret;
1094 }
1095
1096 /*
1097  * Change the total socket buffer size a user has used.
1098  */
1099 int
1100 chgsbsize(struct uidinfo *uip, u_long *hiwat, u_long to, rlim_t max)
1101 {
1102         rlim_t new;
1103
1104         spin_lock(&uip->ui_lock);
1105         new = uip->ui_sbsize + to - *hiwat;
1106         KKASSERT(new >= 0);
1107
1108         /*
1109          * If we are trying to increase the socket buffer size
1110          * Scale down the hi water mark when we exceed the user's
1111          * allowed socket buffer space.
1112          *
1113          * We can't scale down too much or we will blow up atomic packet
1114          * operations.
1115          */
1116         if (to > *hiwat && to > MCLBYTES && new > max) {
1117                 to = to * max / new;
1118                 if (to < MCLBYTES)
1119                         to = MCLBYTES;
1120         }
1121         uip->ui_sbsize = new;
1122         *hiwat = to;
1123         spin_unlock(&uip->ui_lock);
1124         return (1);
1125 }
1126