2005-01-06 23:35:40 +00:00
|
|
|
/*-
|
2017-11-20 19:43:44 +00:00
|
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* Copyright (c) 1982, 1986, 1989, 1991, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
2016-09-15 13:16:20 +00:00
|
|
|
* 3. Neither the name of the University nor the names of its contributors
|
1994-05-24 10:09:53 +00:00
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
1996-03-11 06:05:03 +00:00
|
|
|
* @(#)kern_proc.c 8.7 (Berkeley) 2/14/95
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
#include "opt_ddb.h"
|
2002-06-07 05:41:27 +00:00
|
|
|
#include "opt_ktrace.h"
|
2002-09-07 22:11:45 +00:00
|
|
|
#include "opt_kstack_pages.h"
|
2007-12-02 21:52:18 +00:00
|
|
|
#include "opt_stack.h"
|
2002-06-07 05:41:27 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
2018-12-07 12:22:32 +00:00
|
|
|
#include <sys/bitstring.h>
|
2011-11-22 20:40:18 +00:00
|
|
|
#include <sys/elf.h>
|
2015-07-18 09:02:50 +00:00
|
|
|
#include <sys/eventhandler.h>
|
2011-11-22 20:40:18 +00:00
|
|
|
#include <sys/exec.h>
|
2015-07-18 09:02:50 +00:00
|
|
|
#include <sys/jail.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/kernel.h>
|
2010-04-21 19:32:00 +00:00
|
|
|
#include <sys/limits.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/lock.h>
|
2011-03-05 14:41:49 +00:00
|
|
|
#include <sys/loginclass.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/malloc.h>
|
2011-11-07 21:13:19 +00:00
|
|
|
#include <sys/mman.h>
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
#include <sys/mount.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/mutex.h>
|
1999-11-16 20:31:58 +00:00
|
|
|
#include <sys/proc.h>
|
2011-11-22 20:40:18 +00:00
|
|
|
#include <sys/ptrace.h>
|
2005-09-27 18:03:15 +00:00
|
|
|
#include <sys/refcount.h>
|
2011-11-24 20:43:37 +00:00
|
|
|
#include <sys/resourcevar.h>
|
2013-03-09 02:32:23 +00:00
|
|
|
#include <sys/rwlock.h>
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
#include <sys/sbuf.h>
|
2003-07-12 02:00:16 +00:00
|
|
|
#include <sys/sysent.h>
|
2002-11-21 01:22:38 +00:00
|
|
|
#include <sys/sched.h>
|
2002-09-28 08:44:31 +00:00
|
|
|
#include <sys/smp.h>
|
2007-12-02 21:52:18 +00:00
|
|
|
#include <sys/stack.h>
|
2012-02-26 14:25:48 +00:00
|
|
|
#include <sys/stat.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/sysctl.h>
|
1998-11-11 10:56:07 +00:00
|
|
|
#include <sys/filedesc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/tty.h>
|
1994-09-25 19:34:02 +00:00
|
|
|
#include <sys/signalvar.h>
|
2008-05-24 06:22:16 +00:00
|
|
|
#include <sys/sdt.h>
|
2001-03-28 11:52:56 +00:00
|
|
|
#include <sys/sx.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/user.h>
|
2005-04-18 02:10:37 +00:00
|
|
|
#include <sys/vnode.h>
|
2015-07-18 09:02:50 +00:00
|
|
|
#include <sys/wait.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
#ifdef DDB
|
|
|
|
#include <ddb/ddb.h>
|
|
|
|
#endif
|
|
|
|
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/vm.h>
|
2012-08-05 14:11:42 +00:00
|
|
|
#include <vm/vm_param.h>
|
2002-07-07 23:05:27 +00:00
|
|
|
#include <vm/vm_extern.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/pmap.h>
|
|
|
|
#include <vm/vm_map.h>
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
#include <vm/vm_object.h>
|
2011-11-07 21:13:19 +00:00
|
|
|
#include <vm/vm_page.h>
|
2002-03-20 04:09:59 +00:00
|
|
|
#include <vm/uma.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2010-04-21 19:32:00 +00:00
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
#include <compat/freebsd32/freebsd32.h>
|
|
|
|
#include <compat/freebsd32/freebsd32_util.h>
|
|
|
|
#endif
|
|
|
|
|
2008-05-24 06:22:16 +00:00
|
|
|
SDT_PROVIDER_DEFINE(proc);
|
|
|
|
|
2002-02-23 11:12:57 +00:00
|
|
|
MALLOC_DEFINE(M_PGRP, "pgrp", "process group header");
|
1997-10-12 20:26:33 +00:00
|
|
|
MALLOC_DEFINE(M_SESSION, "session", "session header");
|
1998-02-20 13:52:15 +00:00
|
|
|
static MALLOC_DEFINE(M_PROC, "proc", "Proc structures");
|
1997-10-12 20:26:33 +00:00
|
|
|
MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures");
|
1997-10-11 18:31:40 +00:00
|
|
|
|
2002-03-24 05:09:11 +00:00
|
|
|
static void doenterpgrp(struct proc *, struct pgrp *);
|
|
|
|
static void orphanpg(struct pgrp *pg);
|
2009-02-18 21:52:13 +00:00
|
|
|
static void fill_kinfo_aggregate(struct proc *p, struct kinfo_proc *kp);
|
2005-10-02 23:27:56 +00:00
|
|
|
static void fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp);
|
2008-01-10 22:11:20 +00:00
|
|
|
static void fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp,
|
|
|
|
int preferthread);
|
2003-04-18 20:17:05 +00:00
|
|
|
static void pgadjustjobc(struct pgrp *pgrp, int entering);
|
|
|
|
static void pgdelete(struct pgrp *);
|
2004-08-02 00:18:36 +00:00
|
|
|
static int proc_ctor(void *mem, int size, void *arg, int flags);
|
2002-07-07 23:05:27 +00:00
|
|
|
static void proc_dtor(void *mem, int size, void *arg);
|
2004-08-02 00:18:36 +00:00
|
|
|
static int proc_init(void *mem, int size, int flags);
|
2002-07-07 23:05:27 +00:00
|
|
|
static void proc_fini(void *mem, int size);
|
2008-07-25 11:55:32 +00:00
|
|
|
static void pargs_free(struct pargs *pa);
|
2002-07-07 23:05:27 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1996-03-11 06:05:03 +00:00
|
|
|
* Other process lists
|
|
|
|
*/
|
|
|
|
struct pidhashhead *pidhashtbl;
|
2018-11-21 18:56:15 +00:00
|
|
|
struct sx *pidhashtbl_lock;
|
1996-03-11 06:05:03 +00:00
|
|
|
u_long pidhash;
|
2018-11-21 18:56:15 +00:00
|
|
|
u_long pidhashlock;
|
1996-03-11 06:05:03 +00:00
|
|
|
struct pgrphashhead *pgrphashtbl;
|
|
|
|
u_long pgrphash;
|
|
|
|
struct proclist allproc;
|
2017-09-08 06:46:02 +00:00
|
|
|
struct sx __exclusive_cache_line allproc_lock;
|
|
|
|
struct sx __exclusive_cache_line proctree_lock;
|
|
|
|
struct mtx __exclusive_cache_line ppeers_lock;
|
2018-12-07 12:22:32 +00:00
|
|
|
struct mtx __exclusive_cache_line procid_lock;
|
2002-03-20 04:09:59 +00:00
|
|
|
uma_zone_t proc_zone;
|
1996-03-11 06:05:03 +00:00
|
|
|
|
2015-11-12 22:00:59 +00:00
|
|
|
/*
|
|
|
|
* The offset of various fields in struct proc and struct thread.
|
|
|
|
* These are used by kernel debuggers to enumerate kernel threads and
|
|
|
|
* processes.
|
|
|
|
*/
|
|
|
|
const int proc_off_p_pid = offsetof(struct proc, p_pid);
|
|
|
|
const int proc_off_p_comm = offsetof(struct proc, p_comm);
|
|
|
|
const int proc_off_p_list = offsetof(struct proc, p_list);
|
|
|
|
const int proc_off_p_threads = offsetof(struct proc, p_threads);
|
|
|
|
const int thread_off_td_tid = offsetof(struct thread, td_tid);
|
|
|
|
const int thread_off_td_name = offsetof(struct thread, td_name);
|
|
|
|
const int thread_off_td_oncpu = offsetof(struct thread, td_oncpu);
|
|
|
|
const int thread_off_td_pcb = offsetof(struct thread, td_pcb);
|
|
|
|
const int thread_off_td_plist = offsetof(struct thread, td_plist);
|
|
|
|
|
2017-11-09 22:51:48 +00:00
|
|
|
EVENTHANDLER_LIST_DEFINE(process_ctor);
|
|
|
|
EVENTHANDLER_LIST_DEFINE(process_dtor);
|
|
|
|
EVENTHANDLER_LIST_DEFINE(process_init);
|
|
|
|
EVENTHANDLER_LIST_DEFINE(process_fini);
|
|
|
|
EVENTHANDLER_LIST_DEFINE(process_exit);
|
|
|
|
EVENTHANDLER_LIST_DEFINE(process_fork);
|
|
|
|
EVENTHANDLER_LIST_DEFINE(process_exec);
|
|
|
|
|
2002-09-07 22:11:45 +00:00
|
|
|
int kstack_pages = KSTACK_PAGES;
|
2010-11-14 08:06:29 +00:00
|
|
|
SYSCTL_INT(_kern, OID_AUTO, kstack_pages, CTLFLAG_RD, &kstack_pages, 0,
|
2010-11-14 16:10:15 +00:00
|
|
|
"Kernel stack size in pages");
|
2014-07-09 19:11:57 +00:00
|
|
|
static int vmmap_skip_res_cnt = 0;
|
|
|
|
SYSCTL_INT(_kern, OID_AUTO, proc_vmmap_skip_resident_count, CTLFLAG_RW,
|
|
|
|
&vmmap_skip_res_cnt, 0,
|
|
|
|
"Skip calculation of the pages resident count in kern.proc.vmmap");
|
2002-09-07 22:11:45 +00:00
|
|
|
|
2002-04-06 08:13:52 +00:00
|
|
|
CTASSERT(sizeof(struct kinfo_proc) == KINFO_PROC_SIZE);
|
2010-04-24 12:49:52 +00:00
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
CTASSERT(sizeof(struct kinfo_proc32) == KINFO_PROC32_SIZE);
|
|
|
|
#endif
|
2002-04-06 08:13:52 +00:00
|
|
|
|
1996-03-11 06:05:03 +00:00
|
|
|
/*
|
|
|
|
* Initialize global process hashing structures.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
2016-06-05 16:55:55 +00:00
|
|
|
procinit(void)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2018-11-21 18:56:15 +00:00
|
|
|
u_long i;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-03-28 11:52:56 +00:00
|
|
|
sx_init(&allproc_lock, "allproc");
|
|
|
|
sx_init(&proctree_lock, "proctree");
|
2002-10-15 00:14:32 +00:00
|
|
|
mtx_init(&ppeers_lock, "p_peers", NULL, MTX_DEF);
|
2018-12-07 12:22:32 +00:00
|
|
|
mtx_init(&procid_lock, "procid", NULL, MTX_DEF);
|
1996-03-11 06:05:03 +00:00
|
|
|
LIST_INIT(&allproc);
|
|
|
|
pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash);
|
2018-11-21 18:56:15 +00:00
|
|
|
pidhashlock = (pidhash + 1) / 64;
|
|
|
|
if (pidhashlock > 0)
|
|
|
|
pidhashlock--;
|
|
|
|
pidhashtbl_lock = malloc(sizeof(*pidhashtbl_lock) * (pidhashlock + 1),
|
|
|
|
M_PROC, M_WAITOK | M_ZERO);
|
|
|
|
for (i = 0; i < pidhashlock + 1; i++)
|
2019-04-15 01:27:15 +00:00
|
|
|
sx_init_flags(&pidhashtbl_lock[i], "pidhash", SX_DUPOK);
|
1996-03-11 06:05:03 +00:00
|
|
|
pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash);
|
2002-11-21 01:22:38 +00:00
|
|
|
proc_zone = uma_zcreate("PROC", sched_sizeof_proc(),
|
2002-07-07 23:05:27 +00:00
|
|
|
proc_ctor, proc_dtor, proc_init, proc_fini,
|
|
|
|
UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
|
2000-09-05 22:11:13 +00:00
|
|
|
uihashinit();
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2002-07-07 23:05:27 +00:00
|
|
|
/*
|
|
|
|
* Prepare a proc for use.
|
|
|
|
*/
|
2004-08-02 00:18:36 +00:00
|
|
|
static int
|
|
|
|
proc_ctor(void *mem, int size, void *arg, int flags)
|
2002-07-07 23:05:27 +00:00
|
|
|
{
|
|
|
|
struct proc *p;
|
2017-02-19 13:15:33 +00:00
|
|
|
struct thread *td;
|
2002-07-07 23:05:27 +00:00
|
|
|
|
|
|
|
p = (struct proc *)mem;
|
2017-11-09 22:51:48 +00:00
|
|
|
EVENTHANDLER_DIRECT_INVOKE(process_ctor, p);
|
2017-02-19 13:15:33 +00:00
|
|
|
td = FIRST_THREAD_IN_PROC(p);
|
|
|
|
if (td != NULL) {
|
|
|
|
/* Make sure all thread constructors are executed */
|
2017-11-09 22:51:48 +00:00
|
|
|
EVENTHANDLER_DIRECT_INVOKE(thread_ctor, td);
|
2017-02-19 13:15:33 +00:00
|
|
|
}
|
2004-08-02 00:18:36 +00:00
|
|
|
return (0);
|
2002-07-07 23:05:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reclaim a proc after use.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
proc_dtor(void *mem, int size, void *arg)
|
|
|
|
{
|
|
|
|
struct proc *p;
|
2002-09-06 07:00:37 +00:00
|
|
|
struct thread *td;
|
2002-07-07 23:05:27 +00:00
|
|
|
|
2002-09-06 07:00:37 +00:00
|
|
|
/* INVARIANTS checks go here */
|
2002-07-07 23:05:27 +00:00
|
|
|
p = (struct proc *)mem;
|
2007-11-15 13:28:54 +00:00
|
|
|
td = FIRST_THREAD_IN_PROC(p);
|
2007-11-05 11:36:16 +00:00
|
|
|
if (td != NULL) {
|
2004-09-05 02:09:54 +00:00
|
|
|
#ifdef INVARIANTS
|
2007-11-05 11:36:16 +00:00
|
|
|
KASSERT((p->p_numthreads == 1),
|
|
|
|
("bad number of threads in exiting process"));
|
|
|
|
KASSERT(STAILQ_EMPTY(&p->p_ktr), ("proc_dtor: non-empty p_ktr"));
|
2004-09-05 02:09:54 +00:00
|
|
|
#endif
|
Update ZFS from version 6 to 13 and bring some FreeBSD-specific changes.
This bring huge amount of changes, I'll enumerate only user-visible changes:
- Delegated Administration
Allows regular users to perform ZFS operations, like file system
creation, snapshot creation, etc.
- L2ARC
Level 2 cache for ZFS - allows to use additional disks for cache.
Huge performance improvements mostly for random read of mostly
static content.
- slog
Allow to use additional disks for ZFS Intent Log to speed up
operations like fsync(2).
- vfs.zfs.super_owner
Allows regular users to perform privileged operations on files stored
on ZFS file systems owned by him. Very careful with this one.
- chflags(2)
Not all the flags are supported. This still needs work.
- ZFSBoot
Support to boot off of ZFS pool. Not finished, AFAIK.
Submitted by: dfr
- Snapshot properties
- New failure modes
Before if write requested failed, system paniced. Now one
can select from one of three failure modes:
- panic - panic on write error
- wait - wait for disk to reappear
- continue - serve read requests if possible, block write requests
- Refquota, refreservation properties
Just quota and reservation properties, but don't count space consumed
by children file systems, clones and snapshots.
- Sparse volumes
ZVOLs that don't reserve space in the pool.
- External attributes
Compatible with extattr(2).
- NFSv4-ACLs
Not sure about the status, might not be complete yet.
Submitted by: trasz
- Creation-time properties
- Regression tests for zpool(8) command.
Obtained from: OpenSolaris
2008-11-17 20:49:29 +00:00
|
|
|
/* Free all OSD associated to this thread. */
|
|
|
|
osd_thread_exit(td);
|
2017-06-03 14:12:17 +00:00
|
|
|
td_softdep_cleanup(td);
|
|
|
|
MPASS(td->td_su == NULL);
|
2017-02-19 13:15:33 +00:00
|
|
|
|
|
|
|
/* Make sure all thread destructors are executed */
|
2017-11-09 22:51:48 +00:00
|
|
|
EVENTHANDLER_DIRECT_INVOKE(thread_dtor, td);
|
2007-11-05 11:36:16 +00:00
|
|
|
}
|
2017-11-09 22:51:48 +00:00
|
|
|
EVENTHANDLER_DIRECT_INVOKE(process_dtor, p);
|
2005-11-08 09:09:26 +00:00
|
|
|
if (p->p_ksi != NULL)
|
|
|
|
KASSERT(! KSI_ONQ(p->p_ksi), ("SIGCHLD queue"));
|
2002-07-07 23:05:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize type-stable parts of a proc (when newly created).
|
|
|
|
*/
|
2004-08-02 00:18:36 +00:00
|
|
|
static int
|
|
|
|
proc_init(void *mem, int size, int flags)
|
2002-07-07 23:05:27 +00:00
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
p = (struct proc *)mem;
|
2015-03-21 20:25:34 +00:00
|
|
|
mtx_init(&p->p_mtx, "process lock", NULL, MTX_DEF | MTX_DUPOK | MTX_NEW);
|
|
|
|
mtx_init(&p->p_slock, "process slock", NULL, MTX_SPIN | MTX_NEW);
|
|
|
|
mtx_init(&p->p_statmtx, "pstatl", NULL, MTX_SPIN | MTX_NEW);
|
|
|
|
mtx_init(&p->p_itimmtx, "pitiml", NULL, MTX_SPIN | MTX_NEW);
|
|
|
|
mtx_init(&p->p_profmtx, "pprofl", NULL, MTX_SPIN | MTX_NEW);
|
2008-12-05 20:50:24 +00:00
|
|
|
cv_init(&p->p_pwait, "ppwait");
|
2007-11-05 11:36:16 +00:00
|
|
|
TAILQ_INIT(&p->p_threads); /* all threads in proc */
|
2017-11-09 22:51:48 +00:00
|
|
|
EVENTHANDLER_DIRECT_INVOKE(process_init, p);
|
2004-11-20 02:28:48 +00:00
|
|
|
p->p_stats = pstats_alloc();
|
2015-12-18 16:33:15 +00:00
|
|
|
p->p_pgrp = NULL;
|
2004-08-02 00:18:36 +00:00
|
|
|
return (0);
|
2002-07-07 23:05:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2004-09-19 18:34:17 +00:00
|
|
|
* UMA should ensure that this function is never called.
|
|
|
|
* Freeing a proc structure would violate type stability.
|
2002-07-07 23:05:27 +00:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
proc_fini(void *mem, int size)
|
|
|
|
{
|
2005-10-24 20:15:23 +00:00
|
|
|
#ifdef notnow
|
|
|
|
struct proc *p;
|
2002-07-07 23:05:27 +00:00
|
|
|
|
2005-10-24 20:15:23 +00:00
|
|
|
p = (struct proc *)mem;
|
2017-11-09 22:51:48 +00:00
|
|
|
EVENTHANDLER_DIRECT_INVOKE(process_fini, p);
|
2005-10-24 20:15:23 +00:00
|
|
|
pstats_free(p->p_stats);
|
|
|
|
thread_free(FIRST_THREAD_IN_PROC(p));
|
|
|
|
mtx_destroy(&p->p_mtx);
|
2005-11-08 09:09:26 +00:00
|
|
|
if (p->p_ksi != NULL)
|
|
|
|
ksiginfo_free(p->p_ksi);
|
2005-10-24 20:15:23 +00:00
|
|
|
#else
|
2004-09-19 18:34:17 +00:00
|
|
|
panic("proc reclaimed");
|
2005-10-24 20:15:23 +00:00
|
|
|
#endif
|
2002-07-07 23:05:27 +00:00
|
|
|
}
|
|
|
|
|
2018-12-07 12:22:32 +00:00
|
|
|
/*
|
|
|
|
* PID space management.
|
|
|
|
*
|
|
|
|
* These bitmaps are used by fork_findpid.
|
|
|
|
*/
|
|
|
|
bitstr_t bit_decl(proc_id_pidmap, PID_MAX);
|
|
|
|
bitstr_t bit_decl(proc_id_grpidmap, PID_MAX);
|
|
|
|
bitstr_t bit_decl(proc_id_sessidmap, PID_MAX);
|
|
|
|
bitstr_t bit_decl(proc_id_reapmap, PID_MAX);
|
|
|
|
|
|
|
|
static bitstr_t *proc_id_array[] = {
|
|
|
|
proc_id_pidmap,
|
|
|
|
proc_id_grpidmap,
|
|
|
|
proc_id_sessidmap,
|
|
|
|
proc_id_reapmap,
|
|
|
|
};
|
|
|
|
|
|
|
|
void
|
|
|
|
proc_id_set(int type, pid_t id)
|
|
|
|
{
|
|
|
|
|
|
|
|
KASSERT(type >= 0 && type < nitems(proc_id_array),
|
|
|
|
("invalid type %d\n", type));
|
|
|
|
mtx_lock(&procid_lock);
|
|
|
|
KASSERT(bit_test(proc_id_array[type], id) == 0,
|
|
|
|
("bit %d already set in %d\n", id, type));
|
|
|
|
bit_set(proc_id_array[type], id);
|
|
|
|
mtx_unlock(&procid_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
proc_id_set_cond(int type, pid_t id)
|
|
|
|
{
|
|
|
|
|
|
|
|
KASSERT(type >= 0 && type < nitems(proc_id_array),
|
|
|
|
("invalid type %d\n", type));
|
|
|
|
if (bit_test(proc_id_array[type], id))
|
|
|
|
return;
|
|
|
|
mtx_lock(&procid_lock);
|
|
|
|
bit_set(proc_id_array[type], id);
|
|
|
|
mtx_unlock(&procid_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
proc_id_clear(int type, pid_t id)
|
|
|
|
{
|
|
|
|
|
|
|
|
KASSERT(type >= 0 && type < nitems(proc_id_array),
|
|
|
|
("invalid type %d\n", type));
|
|
|
|
mtx_lock(&procid_lock);
|
|
|
|
KASSERT(bit_test(proc_id_array[type], id) != 0,
|
|
|
|
("bit %d not set in %d\n", id, type));
|
|
|
|
bit_clear(proc_id_array[type], id);
|
|
|
|
mtx_unlock(&procid_lock);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Is p an inferior of the current process?
|
|
|
|
*/
|
2000-06-23 07:10:34 +00:00
|
|
|
int
|
2014-08-07 05:47:53 +00:00
|
|
|
inferior(struct proc *p)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-11-12 18:56:49 +00:00
|
|
|
|
|
|
|
sx_assert(&proctree_lock, SX_LOCKED);
|
2014-08-07 05:47:53 +00:00
|
|
|
PROC_LOCK_ASSERT(p, MA_OWNED);
|
|
|
|
for (; p != curproc; p = proc_realparent(p)) {
|
2001-11-13 16:55:54 +00:00
|
|
|
if (p->p_pid == 0)
|
|
|
|
return (0);
|
2014-08-07 05:47:53 +00:00
|
|
|
}
|
2001-11-13 16:55:54 +00:00
|
|
|
return (1);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 01:27:15 +00:00
|
|
|
/*
|
|
|
|
* Shared lock all the pid hash lists.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
pidhash_slockall(void)
|
|
|
|
{
|
|
|
|
u_long i;
|
|
|
|
|
|
|
|
for (i = 0; i < pidhashlock + 1; i++)
|
|
|
|
sx_slock(&pidhashtbl_lock[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Shared unlock all the pid hash lists.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
pidhash_sunlockall(void)
|
|
|
|
{
|
|
|
|
u_long i;
|
|
|
|
|
|
|
|
for (i = 0; i < pidhashlock + 1; i++)
|
|
|
|
sx_sunlock(&pidhashtbl_lock[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Similar to pfind_any(), this function finds zombies.
|
|
|
|
*/
|
|
|
|
struct proc *
|
|
|
|
pfind_any_locked(pid_t pid)
|
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
sx_assert(PIDHASHLOCK(pid), SX_LOCKED);
|
|
|
|
LIST_FOREACH(p, PIDHASH(pid), p_hash) {
|
|
|
|
if (p->p_pid == pid) {
|
|
|
|
PROC_LOCK(p);
|
|
|
|
if (p->p_state == PRS_NEW) {
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
p = NULL;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (p);
|
|
|
|
}
|
|
|
|
|
2018-11-21 20:15:56 +00:00
|
|
|
/*
|
|
|
|
* Locate a process by number.
|
|
|
|
*
|
|
|
|
* By not returning processes in the PRS_NEW state, we allow callers to avoid
|
|
|
|
* testing for that condition to avoid dereferencing p_ucred, et al.
|
|
|
|
*/
|
|
|
|
static __always_inline struct proc *
|
|
|
|
_pfind(pid_t pid, bool zombie)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2012-11-16 08:25:06 +00:00
|
|
|
struct proc *p;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2018-11-21 20:15:56 +00:00
|
|
|
p = curproc;
|
|
|
|
if (p->p_pid == pid) {
|
|
|
|
PROC_LOCK(p);
|
|
|
|
return (p);
|
|
|
|
}
|
|
|
|
sx_slock(PIDHASHLOCK(pid));
|
2012-11-16 08:25:06 +00:00
|
|
|
LIST_FOREACH(p, PIDHASH(pid), p_hash) {
|
2001-04-24 00:51:53 +00:00
|
|
|
if (p->p_pid == pid) {
|
2011-03-24 18:40:11 +00:00
|
|
|
PROC_LOCK(p);
|
2018-11-21 20:15:56 +00:00
|
|
|
if (p->p_state == PRS_NEW ||
|
2018-12-28 13:32:14 +00:00
|
|
|
(!zombie && p->p_state == PRS_ZOMBIE)) {
|
2011-03-24 18:40:11 +00:00
|
|
|
PROC_UNLOCK(p);
|
2004-08-14 17:15:16 +00:00
|
|
|
p = NULL;
|
|
|
|
}
|
2000-11-22 07:42:04 +00:00
|
|
|
break;
|
2001-04-24 00:51:53 +00:00
|
|
|
}
|
2012-11-16 08:25:06 +00:00
|
|
|
}
|
2018-11-21 20:15:56 +00:00
|
|
|
sx_sunlock(PIDHASHLOCK(pid));
|
2012-11-16 08:25:06 +00:00
|
|
|
return (p);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct proc *
|
|
|
|
pfind(pid_t pid)
|
|
|
|
{
|
|
|
|
|
2018-11-21 20:15:56 +00:00
|
|
|
return (_pfind(pid, false));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2017-11-11 18:04:39 +00:00
|
|
|
/*
|
|
|
|
* Same as pfind but allow zombies.
|
|
|
|
*/
|
|
|
|
struct proc *
|
|
|
|
pfind_any(pid_t pid)
|
|
|
|
{
|
|
|
|
|
2018-11-21 20:15:56 +00:00
|
|
|
return (_pfind(pid, true));
|
2017-11-11 18:04:39 +00:00
|
|
|
}
|
|
|
|
|
2012-04-23 20:56:05 +00:00
|
|
|
static struct proc *
|
2018-11-21 20:15:56 +00:00
|
|
|
pfind_tid(pid_t tid)
|
2012-04-23 20:56:05 +00:00
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
struct thread *td;
|
|
|
|
|
2018-11-21 20:15:56 +00:00
|
|
|
sx_slock(&allproc_lock);
|
2012-04-23 20:56:05 +00:00
|
|
|
FOREACH_PROC_IN_SYSTEM(p) {
|
|
|
|
PROC_LOCK(p);
|
|
|
|
if (p->p_state == PRS_NEW) {
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
FOREACH_THREAD_IN_PROC(p, td) {
|
|
|
|
if (td->td_tid == tid)
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
}
|
|
|
|
found:
|
2018-11-21 20:15:56 +00:00
|
|
|
sx_sunlock(&allproc_lock);
|
2012-04-23 20:56:05 +00:00
|
|
|
return (p);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2002-02-23 11:12:57 +00:00
|
|
|
* Locate a process group by number.
|
2002-04-16 17:03:05 +00:00
|
|
|
* The caller must hold proctree_lock.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
struct pgrp *
|
2016-07-27 14:27:08 +00:00
|
|
|
pgfind(pid_t pgid)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2016-07-27 14:27:08 +00:00
|
|
|
struct pgrp *pgrp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-04-16 17:03:05 +00:00
|
|
|
sx_assert(&proctree_lock, SX_LOCKED);
|
2002-02-23 11:12:57 +00:00
|
|
|
|
|
|
|
LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash) {
|
|
|
|
if (pgrp->pg_id == pgid) {
|
|
|
|
PGRP_LOCK(pgrp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (pgrp);
|
2002-02-23 11:12:57 +00:00
|
|
|
}
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
2011-12-17 16:59:22 +00:00
|
|
|
/*
|
|
|
|
* Locate process and do additional manipulations, depending on flags.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
pget(pid_t pid, int flags, struct proc **pp)
|
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
int error;
|
|
|
|
|
2017-11-03 19:21:36 +00:00
|
|
|
p = curproc;
|
|
|
|
if (p->p_pid == pid) {
|
|
|
|
PROC_LOCK(p);
|
2012-11-25 19:31:42 +00:00
|
|
|
} else {
|
2018-11-21 20:15:56 +00:00
|
|
|
p = NULL;
|
2017-11-03 19:21:36 +00:00
|
|
|
if (pid <= PID_MAX) {
|
2018-11-21 20:15:56 +00:00
|
|
|
if ((flags & PGET_NOTWEXIT) == 0)
|
|
|
|
p = pfind_any(pid);
|
|
|
|
else
|
|
|
|
p = pfind(pid);
|
2017-11-03 19:21:36 +00:00
|
|
|
} else if ((flags & PGET_NOTID) == 0) {
|
2018-11-21 20:15:56 +00:00
|
|
|
p = pfind_tid(pid);
|
2017-11-03 19:21:36 +00:00
|
|
|
}
|
|
|
|
if (p == NULL)
|
|
|
|
return (ESRCH);
|
|
|
|
if ((flags & PGET_CANSEE) != 0) {
|
|
|
|
error = p_cansee(curthread, p);
|
|
|
|
if (error != 0)
|
|
|
|
goto errout;
|
|
|
|
}
|
2011-12-17 16:59:22 +00:00
|
|
|
}
|
|
|
|
if ((flags & PGET_CANDEBUG) != 0) {
|
|
|
|
error = p_candebug(curthread, p);
|
|
|
|
if (error != 0)
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
if ((flags & PGET_ISCURRENT) != 0 && curproc != p) {
|
|
|
|
error = EPERM;
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
if ((flags & PGET_NOTWEXIT) != 0 && (p->p_flag & P_WEXIT) != 0) {
|
|
|
|
error = ESRCH;
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
if ((flags & PGET_NOTINEXEC) != 0 && (p->p_flag & P_INEXEC) != 0) {
|
|
|
|
/*
|
|
|
|
* XXXRW: Not clear ESRCH is the right error during proc
|
|
|
|
* execve().
|
|
|
|
*/
|
|
|
|
error = ESRCH;
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
if ((flags & PGET_HOLD) != 0) {
|
|
|
|
_PHOLD(p);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
}
|
|
|
|
*pp = p;
|
|
|
|
return (0);
|
|
|
|
errout:
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2002-02-23 11:12:57 +00:00
|
|
|
* Create a new process group.
|
|
|
|
* pgid must be equal to the pid of p.
|
|
|
|
* Begin a new session if required.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2016-07-27 14:27:08 +00:00
|
|
|
enterpgrp(struct proc *p, pid_t pgid, struct pgrp *pgrp, struct session *sess)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-02-23 11:12:57 +00:00
|
|
|
|
2002-04-16 17:03:05 +00:00
|
|
|
sx_assert(&proctree_lock, SX_XLOCKED);
|
2002-02-23 11:12:57 +00:00
|
|
|
|
|
|
|
KASSERT(pgrp != NULL, ("enterpgrp: pgrp == NULL"));
|
|
|
|
KASSERT(p->p_pid == pgid,
|
|
|
|
("enterpgrp: new pgrp and pid != pgid"));
|
2012-11-13 22:01:25 +00:00
|
|
|
KASSERT(pgfind(pgid) == NULL,
|
2002-02-23 11:12:57 +00:00
|
|
|
("enterpgrp: pgrp with pgid exists"));
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT(!SESS_LEADER(p),
|
1999-01-10 01:58:29 +00:00
|
|
|
("enterpgrp: session leader attempted setpgrp"));
|
|
|
|
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&pgrp->pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK);
|
2002-02-23 11:12:57 +00:00
|
|
|
|
|
|
|
if (sess != NULL) {
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2002-02-23 11:12:57 +00:00
|
|
|
* new session
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&sess->s_mtx, "session", NULL, MTX_DEF);
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK(p);
|
|
|
|
p->p_flag &= ~P_CONTROLT;
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
PGRP_LOCK(pgrp);
|
|
|
|
sess->s_leader = p;
|
|
|
|
sess->s_sid = p->p_pid;
|
2018-12-07 12:22:32 +00:00
|
|
|
proc_id_set(PROC_ID_SESSION, p->p_pid);
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
refcount_init(&sess->s_count, 1);
|
2002-02-23 11:12:57 +00:00
|
|
|
sess->s_ttyvp = NULL;
|
Let access overriding to TTYs depend on the cdev_priv, not the vnode.
Basically this commit changes two things, which improves access to TTYs
in exceptional conditions. Basically the problem was that when you ran
jexec(8) to attach to a jail, you couldn't use /dev/tty (well, also the
node of the actual TTY, e.g. /dev/pts/X). This is very inconvenient if
you want to attach to screens quickly, use ssh(1), etc.
The fixes:
- Cache the cdev_priv of the controlling TTY in struct session. Change
devfs_access() to compare against the cdev_priv instead of the vnode.
This allows you to bypass UNIX permissions, even across different
mounts of devfs.
- Extend devfs_prison_check() to unconditionally expose the device node
of the controlling TTY, even if normal prison nesting rules normally
don't allow this. This actually allows you to interact with this
device node.
To be honest, I'm not really happy with this solution. We now have to
store three pointers to a controlling TTY (s_ttyp, s_ttyvp, s_ttydp).
In an ideal world, we should just get rid of the latter two and only use
s_ttyp, but this makes certian pieces of code very impractical (e.g.
devfs, kern_exit.c).
Reported by: Many people
2009-12-19 18:42:12 +00:00
|
|
|
sess->s_ttydp = NULL;
|
2002-02-23 11:12:57 +00:00
|
|
|
sess->s_ttyp = NULL;
|
|
|
|
bcopy(p->p_session->s_login, sess->s_login,
|
1994-05-24 10:09:53 +00:00
|
|
|
sizeof(sess->s_login));
|
2002-02-23 11:12:57 +00:00
|
|
|
pgrp->pg_session = sess;
|
|
|
|
KASSERT(p == curproc,
|
|
|
|
("enterpgrp: mksession and p != curproc"));
|
|
|
|
} else {
|
|
|
|
pgrp->pg_session = p->p_session;
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
sess_hold(pgrp->pg_session);
|
2002-02-23 11:12:57 +00:00
|
|
|
PGRP_LOCK(pgrp);
|
|
|
|
}
|
|
|
|
pgrp->pg_id = pgid;
|
2018-12-07 12:22:32 +00:00
|
|
|
proc_id_set(PROC_ID_GROUP, p->p_pid);
|
2002-02-23 11:12:57 +00:00
|
|
|
LIST_INIT(&pgrp->pg_members);
|
|
|
|
|
|
|
|
/*
|
2002-04-16 17:03:05 +00:00
|
|
|
* As we have an exclusive lock of proctree_lock,
|
2002-02-23 11:12:57 +00:00
|
|
|
* this should not deadlock.
|
|
|
|
*/
|
|
|
|
LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
|
|
|
|
pgrp->pg_jobc = 0;
|
|
|
|
SLIST_INIT(&pgrp->pg_sigiolst);
|
|
|
|
PGRP_UNLOCK(pgrp);
|
|
|
|
|
|
|
|
doenterpgrp(p, pgrp);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move p to an existing process group
|
|
|
|
*/
|
|
|
|
int
|
2016-07-27 14:27:08 +00:00
|
|
|
enterthispgrp(struct proc *p, struct pgrp *pgrp)
|
2002-02-23 11:12:57 +00:00
|
|
|
{
|
2002-04-16 17:03:05 +00:00
|
|
|
|
|
|
|
sx_assert(&proctree_lock, SX_XLOCKED);
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK_ASSERT(p, MA_NOTOWNED);
|
|
|
|
PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
|
|
|
|
PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED);
|
|
|
|
SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED);
|
|
|
|
KASSERT(pgrp->pg_session == p->p_session,
|
|
|
|
("%s: pgrp's session %p, p->p_session %p.\n",
|
|
|
|
__func__,
|
|
|
|
pgrp->pg_session,
|
|
|
|
p->p_session));
|
|
|
|
KASSERT(pgrp != p->p_pgrp,
|
|
|
|
("%s: p belongs to pgrp.", __func__));
|
|
|
|
|
|
|
|
doenterpgrp(p, pgrp);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move p to a process group
|
|
|
|
*/
|
|
|
|
static void
|
2016-07-27 14:27:08 +00:00
|
|
|
doenterpgrp(struct proc *p, struct pgrp *pgrp)
|
2002-02-23 11:12:57 +00:00
|
|
|
{
|
|
|
|
struct pgrp *savepgrp;
|
|
|
|
|
2002-04-16 17:03:05 +00:00
|
|
|
sx_assert(&proctree_lock, SX_XLOCKED);
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK_ASSERT(p, MA_NOTOWNED);
|
|
|
|
PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
|
|
|
|
PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED);
|
|
|
|
SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED);
|
|
|
|
|
|
|
|
savepgrp = p->p_pgrp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Adjust eligibility of affected pgrps to participate in job control.
|
|
|
|
* Increment eligibility counts before decrementing, otherwise we
|
|
|
|
* could reach 0 spuriously during the first call.
|
|
|
|
*/
|
|
|
|
fixjobc(p, pgrp, 1);
|
|
|
|
fixjobc(p, p->p_pgrp, 0);
|
|
|
|
|
2002-02-23 11:12:57 +00:00
|
|
|
PGRP_LOCK(pgrp);
|
|
|
|
PGRP_LOCK(savepgrp);
|
2001-03-07 03:28:50 +00:00
|
|
|
PROC_LOCK(p);
|
1996-03-11 06:05:03 +00:00
|
|
|
LIST_REMOVE(p, p_pglist);
|
1994-05-24 10:09:53 +00:00
|
|
|
p->p_pgrp = pgrp;
|
2001-03-07 03:28:50 +00:00
|
|
|
PROC_UNLOCK(p);
|
2002-02-23 11:12:57 +00:00
|
|
|
LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
|
|
|
|
PGRP_UNLOCK(savepgrp);
|
|
|
|
PGRP_UNLOCK(pgrp);
|
|
|
|
if (LIST_EMPTY(&savepgrp->pg_members))
|
|
|
|
pgdelete(savepgrp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* remove process from process group
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2016-07-27 14:27:08 +00:00
|
|
|
leavepgrp(struct proc *p)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-02-23 11:12:57 +00:00
|
|
|
struct pgrp *savepgrp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-04-16 17:03:05 +00:00
|
|
|
sx_assert(&proctree_lock, SX_XLOCKED);
|
2002-02-23 11:12:57 +00:00
|
|
|
savepgrp = p->p_pgrp;
|
|
|
|
PGRP_LOCK(savepgrp);
|
2001-03-07 03:28:50 +00:00
|
|
|
PROC_LOCK(p);
|
1996-03-11 06:05:03 +00:00
|
|
|
LIST_REMOVE(p, p_pglist);
|
2001-03-07 03:28:50 +00:00
|
|
|
p->p_pgrp = NULL;
|
|
|
|
PROC_UNLOCK(p);
|
2002-02-23 11:12:57 +00:00
|
|
|
PGRP_UNLOCK(savepgrp);
|
|
|
|
if (LIST_EMPTY(&savepgrp->pg_members))
|
|
|
|
pgdelete(savepgrp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* delete a process group
|
|
|
|
*/
|
1995-12-14 08:32:45 +00:00
|
|
|
static void
|
2016-07-27 14:27:08 +00:00
|
|
|
pgdelete(struct pgrp *pgrp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-02-23 11:12:57 +00:00
|
|
|
struct session *savesess;
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
struct tty *tp;
|
2002-02-23 11:12:57 +00:00
|
|
|
|
2002-04-16 17:03:05 +00:00
|
|
|
sx_assert(&proctree_lock, SX_XLOCKED);
|
2002-02-23 11:12:57 +00:00
|
|
|
PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
|
|
|
|
SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED);
|
|
|
|
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
/*
|
|
|
|
* Reset any sigio structures pointing to us as a result of
|
|
|
|
* F_SETOWN with our pgid.
|
|
|
|
*/
|
|
|
|
funsetownlst(&pgrp->pg_sigiolst);
|
|
|
|
|
2002-05-06 19:31:28 +00:00
|
|
|
PGRP_LOCK(pgrp);
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
tp = pgrp->pg_session->s_ttyp;
|
1996-03-11 06:05:03 +00:00
|
|
|
LIST_REMOVE(pgrp, pg_hash);
|
2002-02-23 11:12:57 +00:00
|
|
|
savesess = pgrp->pg_session;
|
|
|
|
PGRP_UNLOCK(pgrp);
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
|
|
|
|
/* Remove the reference to the pgrp before deallocating it. */
|
|
|
|
if (tp != NULL) {
|
|
|
|
tty_lock(tp);
|
|
|
|
tty_rel_pgrp(tp, pgrp);
|
|
|
|
}
|
|
|
|
|
2018-12-07 12:22:32 +00:00
|
|
|
proc_id_clear(PROC_ID_GROUP, pgrp->pg_id);
|
2002-05-03 07:46:59 +00:00
|
|
|
mtx_destroy(&pgrp->pg_mtx);
|
2008-10-23 15:53:51 +00:00
|
|
|
free(pgrp, M_PGRP);
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
sess_release(savesess);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2003-04-18 20:17:05 +00:00
|
|
|
static void
|
2016-07-27 14:27:08 +00:00
|
|
|
pgadjustjobc(struct pgrp *pgrp, int entering)
|
2003-04-18 20:17:05 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
PGRP_LOCK(pgrp);
|
|
|
|
if (entering)
|
|
|
|
pgrp->pg_jobc++;
|
|
|
|
else {
|
|
|
|
--pgrp->pg_jobc;
|
|
|
|
if (pgrp->pg_jobc == 0)
|
|
|
|
orphanpg(pgrp);
|
|
|
|
}
|
|
|
|
PGRP_UNLOCK(pgrp);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Adjust pgrp jobc counters when specified process changes process group.
|
|
|
|
* We count the number of processes in each process group that "qualify"
|
|
|
|
* the group for terminal job control (those with a parent in a different
|
|
|
|
* process group of the same session). If that count reaches zero, the
|
|
|
|
* process group becomes orphaned. Check both the specified process'
|
|
|
|
* process group and that of its children.
|
|
|
|
* entering == 0 => p is leaving specified group.
|
|
|
|
* entering == 1 => p is entering specified group.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
2016-01-20 23:22:36 +00:00
|
|
|
fixjobc(struct proc *p, struct pgrp *pgrp, int entering)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2016-01-20 23:22:36 +00:00
|
|
|
struct pgrp *hispgrp;
|
|
|
|
struct session *mysession;
|
|
|
|
struct proc *q;
|
2002-02-23 11:12:57 +00:00
|
|
|
|
2002-04-16 17:03:05 +00:00
|
|
|
sx_assert(&proctree_lock, SX_LOCKED);
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK_ASSERT(p, MA_NOTOWNED);
|
|
|
|
PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
|
|
|
|
SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check p's parent to see whether p qualifies its own process
|
|
|
|
* group; if so, adjust count for p's process group.
|
|
|
|
*/
|
2002-02-23 11:12:57 +00:00
|
|
|
mysession = pgrp->pg_session;
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
|
2003-04-18 20:17:05 +00:00
|
|
|
hispgrp->pg_session == mysession)
|
|
|
|
pgadjustjobc(pgrp, entering);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check this process' children to see whether they qualify
|
|
|
|
* their process groups; if so, adjust counts for children's
|
|
|
|
* process groups.
|
|
|
|
*/
|
2016-01-20 23:22:36 +00:00
|
|
|
LIST_FOREACH(q, &p->p_children, p_sibling) {
|
|
|
|
hispgrp = q->p_pgrp;
|
2003-04-18 20:17:05 +00:00
|
|
|
if (hispgrp == pgrp ||
|
|
|
|
hispgrp->pg_session != mysession)
|
|
|
|
continue;
|
2016-01-20 23:22:36 +00:00
|
|
|
if (q->p_state == PRS_ZOMBIE)
|
2003-04-18 20:17:05 +00:00
|
|
|
continue;
|
|
|
|
pgadjustjobc(hispgrp, entering);
|
2002-02-23 11:12:57 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2016-01-20 23:33:58 +00:00
|
|
|
void
|
|
|
|
killjobc(void)
|
|
|
|
{
|
|
|
|
struct session *sp;
|
|
|
|
struct tty *tp;
|
|
|
|
struct proc *p;
|
|
|
|
struct vnode *ttyvp;
|
|
|
|
|
|
|
|
p = curproc;
|
|
|
|
MPASS(p->p_flag & P_WEXIT);
|
|
|
|
/*
|
|
|
|
* Do a quick check to see if there is anything to do with the
|
|
|
|
* proctree_lock held. pgrp and LIST_EMPTY checks are for fixjobc().
|
|
|
|
*/
|
|
|
|
PROC_LOCK(p);
|
|
|
|
if (!SESS_LEADER(p) &&
|
|
|
|
(p->p_pgrp == p->p_pptr->p_pgrp) &&
|
|
|
|
LIST_EMPTY(&p->p_children)) {
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
|
|
|
|
sx_xlock(&proctree_lock);
|
|
|
|
if (SESS_LEADER(p)) {
|
|
|
|
sp = p->p_session;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* s_ttyp is not zero'd; we use this to indicate that
|
|
|
|
* the session once had a controlling terminal. (for
|
|
|
|
* logging and informational purposes)
|
|
|
|
*/
|
|
|
|
SESS_LOCK(sp);
|
|
|
|
ttyvp = sp->s_ttyvp;
|
|
|
|
tp = sp->s_ttyp;
|
|
|
|
sp->s_ttyvp = NULL;
|
|
|
|
sp->s_ttydp = NULL;
|
|
|
|
sp->s_leader = NULL;
|
|
|
|
SESS_UNLOCK(sp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Signal foreground pgrp and revoke access to
|
|
|
|
* controlling terminal if it has not been revoked
|
|
|
|
* already.
|
|
|
|
*
|
|
|
|
* Because the TTY may have been revoked in the mean
|
|
|
|
* time and could already have a new session associated
|
|
|
|
* with it, make sure we don't send a SIGHUP to a
|
|
|
|
* foreground process group that does not belong to this
|
|
|
|
* session.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (tp != NULL) {
|
|
|
|
tty_lock(tp);
|
|
|
|
if (tp->t_session == sp)
|
|
|
|
tty_signal_pgrp(tp, SIGHUP);
|
|
|
|
tty_unlock(tp);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ttyvp != NULL) {
|
|
|
|
sx_xunlock(&proctree_lock);
|
|
|
|
if (vn_lock(ttyvp, LK_EXCLUSIVE) == 0) {
|
|
|
|
VOP_REVOKE(ttyvp, REVOKEALL);
|
|
|
|
VOP_UNLOCK(ttyvp, 0);
|
|
|
|
}
|
|
|
|
vrele(ttyvp);
|
|
|
|
sx_xlock(&proctree_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fixjobc(p, p->p_pgrp, 0);
|
|
|
|
sx_xunlock(&proctree_lock);
|
|
|
|
}
|
|
|
|
|
1995-05-30 08:16:23 +00:00
|
|
|
/*
|
1994-05-24 10:09:53 +00:00
|
|
|
* A process group has become orphaned;
|
|
|
|
* if there are any stopped processes in the group,
|
|
|
|
* hang-up all process in that group.
|
|
|
|
*/
|
|
|
|
static void
|
2016-07-27 14:27:08 +00:00
|
|
|
orphanpg(struct pgrp *pg)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2016-07-27 14:27:08 +00:00
|
|
|
struct proc *p;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-02-23 11:12:57 +00:00
|
|
|
PGRP_LOCK_ASSERT(pg, MA_OWNED);
|
|
|
|
|
1999-11-16 16:28:58 +00:00
|
|
|
LIST_FOREACH(p, &pg->pg_members, p_pglist) {
|
2003-04-18 20:17:05 +00:00
|
|
|
PROC_LOCK(p);
|
2015-09-16 16:40:07 +00:00
|
|
|
if (P_SHOULDSTOP(p) == P_STOPPED_SIG) {
|
2003-04-18 20:17:05 +00:00
|
|
|
PROC_UNLOCK(p);
|
1999-11-16 16:28:58 +00:00
|
|
|
LIST_FOREACH(p, &pg->pg_members, p_pglist) {
|
2001-03-07 03:28:50 +00:00
|
|
|
PROC_LOCK(p);
|
2011-09-16 13:58:51 +00:00
|
|
|
kern_psignal(p, SIGHUP);
|
|
|
|
kern_psignal(p, SIGCONT);
|
2001-03-07 03:28:50 +00:00
|
|
|
PROC_UNLOCK(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2003-04-18 20:17:05 +00:00
|
|
|
PROC_UNLOCK(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-03-17 08:44:41 +00:00
|
|
|
void
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
sess_hold(struct session *s)
|
2005-03-17 08:44:41 +00:00
|
|
|
{
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
|
|
|
|
refcount_acquire(&s->s_count);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
sess_release(struct session *s)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (refcount_release(&s->s_count)) {
|
|
|
|
if (s->s_ttyp != NULL) {
|
|
|
|
tty_lock(s->s_ttyp);
|
|
|
|
tty_rel_sess(s->s_ttyp, s);
|
|
|
|
}
|
2018-12-07 12:22:32 +00:00
|
|
|
proc_id_clear(PROC_ID_SESSION, s->s_sid);
|
2005-03-17 08:44:41 +00:00
|
|
|
mtx_destroy(&s->s_mtx);
|
2008-10-23 15:53:51 +00:00
|
|
|
free(s, M_SESSION);
|
2005-03-17 08:44:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1996-09-14 10:53:48 +00:00
|
|
|
#ifdef DDB
|
|
|
|
|
|
|
|
DB_SHOW_COMMAND(pgrpdump, pgrpdump)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2016-07-27 14:27:08 +00:00
|
|
|
struct pgrp *pgrp;
|
|
|
|
struct proc *p;
|
|
|
|
int i;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1996-03-11 06:05:03 +00:00
|
|
|
for (i = 0; i <= pgrphash; i++) {
|
1999-11-16 16:28:58 +00:00
|
|
|
if (!LIST_EMPTY(&pgrphashtbl[i])) {
|
1996-03-11 06:05:03 +00:00
|
|
|
printf("\tindx %d\n", i);
|
1999-11-16 16:28:58 +00:00
|
|
|
LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) {
|
1998-07-11 07:46:16 +00:00
|
|
|
printf(
|
|
|
|
"\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n",
|
|
|
|
(void *)pgrp, (long)pgrp->pg_id,
|
|
|
|
(void *)pgrp->pg_session,
|
1996-03-11 06:05:03 +00:00
|
|
|
pgrp->pg_session->s_count,
|
1999-11-16 16:28:58 +00:00
|
|
|
(void *)LIST_FIRST(&pgrp->pg_members));
|
|
|
|
LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
|
1998-07-11 07:46:16 +00:00
|
|
|
printf("\t\tpid %ld addr %p pgrp %p\n",
|
|
|
|
(long)p->p_pid, (void *)p,
|
|
|
|
(void *)p->p_pgrp);
|
1996-03-11 06:05:03 +00:00
|
|
|
}
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1996-09-14 10:53:48 +00:00
|
|
|
#endif /* DDB */
|
1995-11-14 09:16:27 +00:00
|
|
|
|
2009-02-18 21:52:13 +00:00
|
|
|
/*
|
|
|
|
* Calculate the kinfo_proc members which contain process-wide
|
|
|
|
* informations.
|
|
|
|
* Must be called with the target process locked.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
fill_kinfo_aggregate(struct proc *p, struct kinfo_proc *kp)
|
|
|
|
{
|
|
|
|
struct thread *td;
|
|
|
|
|
|
|
|
PROC_LOCK_ASSERT(p, MA_OWNED);
|
|
|
|
|
|
|
|
kp->ki_estcpu = 0;
|
|
|
|
kp->ki_pctcpu = 0;
|
|
|
|
FOREACH_THREAD_IN_PROC(p, td) {
|
|
|
|
thread_lock(td);
|
|
|
|
kp->ki_pctcpu += sched_pctcpu(td);
|
2016-04-17 11:04:27 +00:00
|
|
|
kp->ki_estcpu += sched_estcpu(td);
|
2009-02-18 21:52:13 +00:00
|
|
|
thread_unlock(td);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1995-11-14 09:16:27 +00:00
|
|
|
/*
|
2005-10-02 23:27:56 +00:00
|
|
|
* Clear kinfo_proc and fill in any information that is common
|
|
|
|
* to all threads in the process.
|
2002-04-09 20:10:46 +00:00
|
|
|
* Must be called with the target process locked.
|
1995-11-14 09:16:27 +00:00
|
|
|
*/
|
2005-10-02 23:27:56 +00:00
|
|
|
static void
|
|
|
|
fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp)
|
2003-06-12 16:41:50 +00:00
|
|
|
{
|
2003-03-31 22:49:17 +00:00
|
|
|
struct thread *td0;
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
struct tty *tp;
|
|
|
|
struct session *sp;
|
2005-03-12 14:28:34 +00:00
|
|
|
struct ucred *cred;
|
- Merge struct procsig with struct sigacts.
- Move struct sigacts out of the u-area and malloc() it using the
M_SUBPROC malloc bucket.
- Add a small sigacts_*() API for managing sigacts structures: sigacts_alloc(),
sigacts_free(), sigacts_copy(), sigacts_share(), and sigacts_shared().
- Remove the p_sigignore, p_sigacts, and p_sigcatch macros.
- Add a mutex to struct sigacts that protects all the members of the struct.
- Add sigacts locking.
- Remove Giant from nosys(), kill(), killpg(), and kern_sigaction() now
that sigacts is locked.
- Several in-kernel functions such as psignal(), tdsignal(), trapsignal(),
and thread_stopped() are now MP safe.
Reviewed by: arch@
Approved by: re (rwatson)
2003-05-13 20:36:02 +00:00
|
|
|
struct sigacts *ps;
|
2016-07-27 11:08:59 +00:00
|
|
|
struct timeval boottime;
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
|
2008-03-19 06:19:01 +00:00
|
|
|
PROC_LOCK_ASSERT(p, MA_OWNED);
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
bzero(kp, sizeof(*kp));
|
|
|
|
|
|
|
|
kp->ki_structsize = sizeof(*kp);
|
|
|
|
kp->ki_paddr = p;
|
2008-03-12 10:12:01 +00:00
|
|
|
kp->ki_addr =/* p->p_addr; */0; /* XXX */
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
kp->ki_args = p->p_args;
|
|
|
|
kp->ki_textvp = p->p_textvp;
|
2002-06-07 05:41:27 +00:00
|
|
|
#ifdef KTRACE
|
2003-03-13 18:24:22 +00:00
|
|
|
kp->ki_tracep = p->p_tracevp;
|
2002-06-07 05:41:27 +00:00
|
|
|
kp->ki_traceflag = p->p_traceflag;
|
|
|
|
#endif
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
kp->ki_fd = p->p_fd;
|
|
|
|
kp->ki_vmspace = p->p_vmspace;
|
2005-03-12 14:31:04 +00:00
|
|
|
kp->ki_flag = p->p_flag;
|
2013-09-19 18:53:42 +00:00
|
|
|
kp->ki_flag2 = p->p_flag2;
|
2005-03-12 14:28:34 +00:00
|
|
|
cred = p->p_ucred;
|
|
|
|
if (cred) {
|
|
|
|
kp->ki_uid = cred->cr_uid;
|
|
|
|
kp->ki_ruid = cred->cr_ruid;
|
|
|
|
kp->ki_svuid = cred->cr_svuid;
|
2011-03-01 13:23:37 +00:00
|
|
|
kp->ki_cr_flags = 0;
|
|
|
|
if (cred->cr_flags & CRED_FLAG_CAPMODE)
|
|
|
|
kp->ki_cr_flags |= KI_CRF_CAPABILITY_MODE;
|
2009-07-24 15:03:10 +00:00
|
|
|
/* XXX bde doesn't like KI_NGROUPS */
|
|
|
|
if (cred->cr_ngroups > KI_NGROUPS) {
|
|
|
|
kp->ki_ngroups = KI_NGROUPS;
|
|
|
|
kp->ki_cr_flags |= KI_CRF_GRP_OVERFLOW;
|
|
|
|
} else
|
|
|
|
kp->ki_ngroups = cred->cr_ngroups;
|
|
|
|
bcopy(cred->cr_groups, kp->ki_groups,
|
|
|
|
kp->ki_ngroups * sizeof(gid_t));
|
2005-03-12 14:28:34 +00:00
|
|
|
kp->ki_rgid = cred->cr_rgid;
|
|
|
|
kp->ki_svgid = cred->cr_svgid;
|
2005-03-12 14:31:04 +00:00
|
|
|
/* If jailed(cred), emulate the old P_JAILED flag. */
|
2005-03-20 10:35:23 +00:00
|
|
|
if (jailed(cred)) {
|
2005-03-12 14:31:04 +00:00
|
|
|
kp->ki_flag |= P_JAILED;
|
2009-05-27 14:11:23 +00:00
|
|
|
/* If inside the jail, use 0 as a jail ID. */
|
|
|
|
if (cred->cr_prison != curthread->td_ucred->cr_prison)
|
2005-03-20 10:35:23 +00:00
|
|
|
kp->ki_jid = cred->cr_prison->pr_id;
|
|
|
|
}
|
2011-03-05 14:41:49 +00:00
|
|
|
strlcpy(kp->ki_loginclass, cred->cr_loginclass->lc_name,
|
|
|
|
sizeof(kp->ki_loginclass));
|
1995-11-14 09:16:27 +00:00
|
|
|
}
|
2005-03-12 14:28:34 +00:00
|
|
|
ps = p->p_sigacts;
|
|
|
|
if (ps) {
|
- Merge struct procsig with struct sigacts.
- Move struct sigacts out of the u-area and malloc() it using the
M_SUBPROC malloc bucket.
- Add a small sigacts_*() API for managing sigacts structures: sigacts_alloc(),
sigacts_free(), sigacts_copy(), sigacts_share(), and sigacts_shared().
- Remove the p_sigignore, p_sigacts, and p_sigcatch macros.
- Add a mutex to struct sigacts that protects all the members of the struct.
- Add sigacts locking.
- Remove Giant from nosys(), kill(), killpg(), and kern_sigaction() now
that sigacts is locked.
- Several in-kernel functions such as psignal(), tdsignal(), trapsignal(),
and thread_stopped() are now MP safe.
Reviewed by: arch@
Approved by: re (rwatson)
2003-05-13 20:36:02 +00:00
|
|
|
mtx_lock(&ps->ps_mtx);
|
|
|
|
kp->ki_sigignore = ps->ps_sigignore;
|
|
|
|
kp->ki_sigcatch = ps->ps_sigcatch;
|
|
|
|
mtx_unlock(&ps->ps_mtx);
|
1999-01-13 03:11:43 +00:00
|
|
|
}
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
if (p->p_state != PRS_NEW &&
|
|
|
|
p->p_state != PRS_ZOMBIE &&
|
|
|
|
p->p_vmspace != NULL) {
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
struct vmspace *vm = p->p_vmspace;
|
|
|
|
|
|
|
|
kp->ki_size = vm->vm_map.size;
|
|
|
|
kp->ki_rssize = vmspace_resident_count(vm); /*XXX*/
|
2003-04-25 00:20:40 +00:00
|
|
|
FOREACH_THREAD_IN_PROC(p, td0) {
|
|
|
|
if (!TD_IS_SWAPPED(td0))
|
|
|
|
kp->ki_rssize += td0->td_kstack_pages;
|
2003-04-24 11:03:04 +00:00
|
|
|
}
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
kp->ki_swrss = vm->vm_swrss;
|
|
|
|
kp->ki_tsize = vm->vm_tsize;
|
|
|
|
kp->ki_dsize = vm->vm_dsize;
|
|
|
|
kp->ki_ssize = vm->vm_ssize;
|
2005-10-02 23:27:56 +00:00
|
|
|
} else if (p->p_state == PRS_ZOMBIE)
|
|
|
|
kp->ki_stat = SZOMB;
|
2007-09-17 05:31:39 +00:00
|
|
|
if (kp->ki_flag & P_INMEM)
|
|
|
|
kp->ki_sflag = PS_INMEM;
|
|
|
|
else
|
|
|
|
kp->ki_sflag = 0;
|
2007-09-21 04:10:23 +00:00
|
|
|
/* Calculate legacy swtime as seconds since 'swtick'. */
|
|
|
|
kp->ki_swtime = (ticks - p->p_swtick) / hz;
|
2004-07-29 20:27:59 +00:00
|
|
|
kp->ki_pid = p->p_pid;
|
|
|
|
kp->ki_nice = p->p_nice;
|
2013-08-26 23:48:21 +00:00
|
|
|
kp->ki_fibnum = p->p_fibnum;
|
2010-11-11 08:15:12 +00:00
|
|
|
kp->ki_start = p->p_stats->p_start;
|
2016-07-27 11:08:59 +00:00
|
|
|
getboottime(&boottime);
|
2010-11-11 08:15:12 +00:00
|
|
|
timevaladd(&kp->ki_start, &boottime);
|
2014-11-26 14:10:00 +00:00
|
|
|
PROC_STATLOCK(p);
|
2011-03-24 18:40:11 +00:00
|
|
|
rufetch(p, &kp->ki_rusage);
|
|
|
|
kp->ki_runtime = cputick2usec(p->p_rux.rux_runtime);
|
2010-11-11 08:15:12 +00:00
|
|
|
calcru(p, &kp->ki_rusage.ru_utime, &kp->ki_rusage.ru_stime);
|
2014-11-26 14:10:00 +00:00
|
|
|
PROC_STATUNLOCK(p);
|
2010-11-11 08:15:12 +00:00
|
|
|
calccru(p, &kp->ki_childutime, &kp->ki_childstime);
|
2010-11-11 21:53:46 +00:00
|
|
|
/* Some callers want child times in a single value. */
|
2010-11-11 08:15:12 +00:00
|
|
|
kp->ki_childtime = kp->ki_childstime;
|
|
|
|
timevaladd(&kp->ki_childtime, &kp->ki_childutime);
|
2010-11-11 21:53:46 +00:00
|
|
|
|
2012-05-23 18:10:54 +00:00
|
|
|
FOREACH_THREAD_IN_PROC(p, td0)
|
|
|
|
kp->ki_cow += td0->td_cow;
|
|
|
|
|
2002-02-23 11:12:57 +00:00
|
|
|
tp = NULL;
|
1995-11-14 09:16:27 +00:00
|
|
|
if (p->p_pgrp) {
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
kp->ki_pgid = p->p_pgrp->pg_id;
|
|
|
|
kp->ki_jobc = p->p_pgrp->pg_jobc;
|
|
|
|
sp = p->p_pgrp->pg_session;
|
|
|
|
|
|
|
|
if (sp != NULL) {
|
|
|
|
kp->ki_sid = sp->s_sid;
|
2002-02-23 11:12:57 +00:00
|
|
|
SESS_LOCK(sp);
|
2002-10-17 20:03:38 +00:00
|
|
|
strlcpy(kp->ki_login, sp->s_login,
|
|
|
|
sizeof(kp->ki_login));
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
if (sp->s_ttyvp)
|
2002-01-05 17:18:59 +00:00
|
|
|
kp->ki_kiflag |= KI_CTTY;
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
if (SESS_LEADER(p))
|
|
|
|
kp->ki_kiflag |= KI_SLEADER;
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
/* XXX proctree_lock */
|
2002-02-23 11:12:57 +00:00
|
|
|
tp = sp->s_ttyp;
|
|
|
|
SESS_UNLOCK(sp);
|
1996-05-30 01:21:50 +00:00
|
|
|
}
|
1995-11-14 09:16:27 +00:00
|
|
|
}
|
2002-02-23 11:12:57 +00:00
|
|
|
if ((p->p_flag & P_CONTROLT) && tp != NULL) {
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
kp->ki_tdev = tty_udev(tp);
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
kp->ki_tdev_freebsd11 = kp->ki_tdev; /* truncate */
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
kp->ki_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
|
|
|
|
if (tp->t_session)
|
|
|
|
kp->ki_tsid = tp->t_session->s_sid;
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
} else {
|
2004-06-17 17:16:53 +00:00
|
|
|
kp->ki_tdev = NODEV;
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
kp->ki_tdev_freebsd11 = kp->ki_tdev; /* truncate */
|
|
|
|
}
|
2007-03-23 04:01:08 +00:00
|
|
|
if (p->p_comm[0] != '\0')
|
2002-10-17 20:03:38 +00:00
|
|
|
strlcpy(kp->ki_comm, p->p_comm, sizeof(kp->ki_comm));
|
2004-06-19 14:03:00 +00:00
|
|
|
if (p->p_sysent && p->p_sysent->sv_name != NULL &&
|
|
|
|
p->p_sysent->sv_name[0] != '\0')
|
|
|
|
strlcpy(kp->ki_emul, p->p_sysent->sv_name, sizeof(kp->ki_emul));
|
2002-10-01 17:15:53 +00:00
|
|
|
kp->ki_siglist = p->p_siglist;
|
2015-07-18 09:02:50 +00:00
|
|
|
kp->ki_xstat = KW_EXITCODE(p->p_xexit, p->p_xsig);
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
kp->ki_acflag = p->p_acflag;
|
|
|
|
kp->ki_lock = p->p_lock;
|
2014-09-03 08:14:07 +00:00
|
|
|
if (p->p_pptr) {
|
2018-11-16 17:07:54 +00:00
|
|
|
kp->ki_ppid = p->p_oppid;
|
2014-09-03 08:14:07 +00:00
|
|
|
if (p->p_flag & P_TRACED)
|
|
|
|
kp->ki_tracer = p->p_pptr->p_pid;
|
|
|
|
}
|
1995-11-14 09:16:27 +00:00
|
|
|
}
|
|
|
|
|
2005-10-02 23:27:56 +00:00
|
|
|
/*
|
2010-02-27 15:32:49 +00:00
|
|
|
* Fill in information that is thread specific. Must be called with
|
|
|
|
* target process locked. If 'preferthread' is set, overwrite certain
|
|
|
|
* process-related fields that are maintained for both threads and
|
|
|
|
* processes.
|
2005-10-02 23:27:56 +00:00
|
|
|
*/
|
|
|
|
static void
|
2008-01-10 22:11:20 +00:00
|
|
|
fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp, int preferthread)
|
2005-10-02 23:27:56 +00:00
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
p = td->td_proc;
|
2010-10-08 00:44:53 +00:00
|
|
|
kp->ki_tdaddr = td;
|
2008-03-19 06:19:01 +00:00
|
|
|
PROC_LOCK_ASSERT(p, MA_OWNED);
|
2005-10-02 23:27:56 +00:00
|
|
|
|
2011-07-18 17:33:08 +00:00
|
|
|
if (preferthread)
|
2014-11-26 14:10:00 +00:00
|
|
|
PROC_STATLOCK(p);
|
Commit 14/14 of sched_lock decomposition.
- Use thread_lock() rather than sched_lock for per-thread scheduling
sychronization.
- Use the per-process spinlock rather than the sched_lock for per-process
scheduling synchronization.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-05 00:00:57 +00:00
|
|
|
thread_lock(td);
|
2005-10-02 23:27:56 +00:00
|
|
|
if (td->td_wmesg != NULL)
|
|
|
|
strlcpy(kp->ki_wmesg, td->td_wmesg, sizeof(kp->ki_wmesg));
|
|
|
|
else
|
|
|
|
bzero(kp->ki_wmesg, sizeof(kp->ki_wmesg));
|
2016-12-07 15:04:22 +00:00
|
|
|
if (strlcpy(kp->ki_tdname, td->td_name, sizeof(kp->ki_tdname)) >=
|
|
|
|
sizeof(kp->ki_tdname)) {
|
|
|
|
strlcpy(kp->ki_moretdname,
|
|
|
|
td->td_name + sizeof(kp->ki_tdname) - 1,
|
|
|
|
sizeof(kp->ki_moretdname));
|
|
|
|
} else {
|
|
|
|
bzero(kp->ki_moretdname, sizeof(kp->ki_moretdname));
|
|
|
|
}
|
2005-10-02 23:27:56 +00:00
|
|
|
if (TD_ON_LOCK(td)) {
|
|
|
|
kp->ki_kiflag |= KI_LOCKBLOCK;
|
|
|
|
strlcpy(kp->ki_lockname, td->td_lockname,
|
|
|
|
sizeof(kp->ki_lockname));
|
|
|
|
} else {
|
|
|
|
kp->ki_kiflag &= ~KI_LOCKBLOCK;
|
|
|
|
bzero(kp->ki_lockname, sizeof(kp->ki_lockname));
|
|
|
|
}
|
|
|
|
|
2008-03-12 10:12:01 +00:00
|
|
|
if (p->p_state == PRS_NORMAL) { /* approximate. */
|
2005-10-02 23:27:56 +00:00
|
|
|
if (TD_ON_RUNQ(td) ||
|
|
|
|
TD_CAN_RUN(td) ||
|
|
|
|
TD_IS_RUNNING(td)) {
|
|
|
|
kp->ki_stat = SRUN;
|
|
|
|
} else if (P_SHOULDSTOP(p)) {
|
|
|
|
kp->ki_stat = SSTOP;
|
|
|
|
} else if (TD_IS_SLEEPING(td)) {
|
|
|
|
kp->ki_stat = SSLEEP;
|
|
|
|
} else if (TD_ON_LOCK(td)) {
|
|
|
|
kp->ki_stat = SLOCK;
|
|
|
|
} else {
|
|
|
|
kp->ki_stat = SWAIT;
|
|
|
|
}
|
2005-12-29 13:00:42 +00:00
|
|
|
} else if (p->p_state == PRS_ZOMBIE) {
|
|
|
|
kp->ki_stat = SZOMB;
|
2005-10-02 23:27:56 +00:00
|
|
|
} else {
|
|
|
|
kp->ki_stat = SIDL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Things in the thread */
|
|
|
|
kp->ki_wchan = td->td_wchan;
|
|
|
|
kp->ki_pri.pri_level = td->td_priority;
|
|
|
|
kp->ki_pri.pri_native = td->td_base_pri;
|
2014-10-18 19:36:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: legacy fields; clamp at the old NOCPU value and/or
|
|
|
|
* the maximum u_char CPU value.
|
|
|
|
*/
|
|
|
|
if (td->td_lastcpu == NOCPU)
|
|
|
|
kp->ki_lastcpu_old = NOCPU_OLD;
|
|
|
|
else if (td->td_lastcpu > MAXCPU_OLD)
|
|
|
|
kp->ki_lastcpu_old = MAXCPU_OLD;
|
|
|
|
else
|
|
|
|
kp->ki_lastcpu_old = td->td_lastcpu;
|
|
|
|
|
|
|
|
if (td->td_oncpu == NOCPU)
|
|
|
|
kp->ki_oncpu_old = NOCPU_OLD;
|
|
|
|
else if (td->td_oncpu > MAXCPU_OLD)
|
|
|
|
kp->ki_oncpu_old = MAXCPU_OLD;
|
|
|
|
else
|
|
|
|
kp->ki_oncpu_old = td->td_oncpu;
|
|
|
|
|
2005-10-02 23:27:56 +00:00
|
|
|
kp->ki_lastcpu = td->td_lastcpu;
|
|
|
|
kp->ki_oncpu = td->td_oncpu;
|
|
|
|
kp->ki_tdflags = td->td_flags;
|
|
|
|
kp->ki_tid = td->td_tid;
|
|
|
|
kp->ki_numthreads = p->p_numthreads;
|
|
|
|
kp->ki_pcb = td->td_pcb;
|
|
|
|
kp->ki_kstack = (void *)td->td_kstack;
|
2007-09-21 04:10:23 +00:00
|
|
|
kp->ki_slptime = (ticks - td->td_slptick) / hz;
|
2006-10-26 21:42:22 +00:00
|
|
|
kp->ki_pri.pri_class = td->td_pri_class;
|
|
|
|
kp->ki_pri.pri_user = td->td_user_pri;
|
2005-10-02 23:27:56 +00:00
|
|
|
|
2009-02-18 21:52:13 +00:00
|
|
|
if (preferthread) {
|
2011-07-18 17:33:08 +00:00
|
|
|
rufetchtd(td, &kp->ki_rusage);
|
2010-05-05 16:05:51 +00:00
|
|
|
kp->ki_runtime = cputick2usec(td->td_rux.rux_runtime);
|
2009-02-18 21:52:13 +00:00
|
|
|
kp->ki_pctcpu = sched_pctcpu(td);
|
2016-04-17 11:04:27 +00:00
|
|
|
kp->ki_estcpu = sched_estcpu(td);
|
2012-05-23 18:10:54 +00:00
|
|
|
kp->ki_cow = td->td_cow;
|
2009-02-18 21:52:13 +00:00
|
|
|
}
|
2008-01-10 22:11:20 +00:00
|
|
|
|
2005-10-02 23:27:56 +00:00
|
|
|
/* We can't get this anymore but ps etc never used it anyway. */
|
|
|
|
kp->ki_rqindex = 0;
|
|
|
|
|
2010-02-27 15:32:49 +00:00
|
|
|
if (preferthread)
|
|
|
|
kp->ki_siglist = td->td_siglist;
|
2005-10-02 23:27:56 +00:00
|
|
|
kp->ki_sigmask = td->td_sigmask;
|
Commit 14/14 of sched_lock decomposition.
- Use thread_lock() rather than sched_lock for per-thread scheduling
sychronization.
- Use the per-process spinlock rather than the sched_lock for per-process
scheduling synchronization.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-05 00:00:57 +00:00
|
|
|
thread_unlock(td);
|
2011-07-18 17:33:08 +00:00
|
|
|
if (preferthread)
|
2014-11-26 14:10:00 +00:00
|
|
|
PROC_STATUNLOCK(p);
|
2005-10-02 23:27:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill in a kinfo_proc structure for the specified process.
|
|
|
|
* Must be called with the target process locked.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
fill_kinfo_proc(struct proc *p, struct kinfo_proc *kp)
|
|
|
|
{
|
|
|
|
|
2009-02-18 21:52:13 +00:00
|
|
|
MPASS(FIRST_THREAD_IN_PROC(p) != NULL);
|
|
|
|
|
2005-10-02 23:27:56 +00:00
|
|
|
fill_kinfo_proc_only(p, kp);
|
2009-02-18 21:52:13 +00:00
|
|
|
fill_kinfo_thread(FIRST_THREAD_IN_PROC(p), kp, 0);
|
|
|
|
fill_kinfo_aggregate(p, kp);
|
2005-10-02 23:27:56 +00:00
|
|
|
}
|
|
|
|
|
2004-11-20 02:28:48 +00:00
|
|
|
struct pstats *
|
|
|
|
pstats_alloc(void)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (malloc(sizeof(struct pstats), M_SUBPROC, M_ZERO|M_WAITOK));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy parts of p_stats; zero the rest of p_stats (statistics).
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
pstats_fork(struct pstats *src, struct pstats *dst)
|
|
|
|
{
|
|
|
|
|
|
|
|
bzero(&dst->pstat_startzero,
|
2004-11-20 23:00:59 +00:00
|
|
|
__rangeof(struct pstats, pstat_startzero, pstat_endzero));
|
2004-11-20 02:28:48 +00:00
|
|
|
bcopy(&src->pstat_startcopy, &dst->pstat_startcopy,
|
2004-11-20 23:00:59 +00:00
|
|
|
__rangeof(struct pstats, pstat_startcopy, pstat_endcopy));
|
2004-11-20 02:28:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
pstats_free(struct pstats *ps)
|
|
|
|
{
|
|
|
|
|
|
|
|
free(ps, M_SUBPROC);
|
|
|
|
}
|
|
|
|
|
2010-04-21 19:32:00 +00:00
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function is typically used to copy out the kernel address, so
|
|
|
|
* it can be replaced by assignment of zero.
|
|
|
|
*/
|
|
|
|
static inline uint32_t
|
|
|
|
ptr32_trim(void *ptr)
|
|
|
|
{
|
|
|
|
uintptr_t uptr;
|
|
|
|
|
|
|
|
uptr = (uintptr_t)ptr;
|
|
|
|
return ((uptr > UINT_MAX) ? 0 : uptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define PTRTRIM_CP(src,dst,fld) \
|
|
|
|
do { (dst).fld = ptr32_trim((src).fld); } while (0)
|
|
|
|
|
|
|
|
static void
|
|
|
|
freebsd32_kinfo_proc_out(const struct kinfo_proc *ki, struct kinfo_proc32 *ki32)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
bzero(ki32, sizeof(struct kinfo_proc32));
|
|
|
|
ki32->ki_structsize = sizeof(struct kinfo_proc32);
|
|
|
|
CP(*ki, *ki32, ki_layout);
|
|
|
|
PTRTRIM_CP(*ki, *ki32, ki_args);
|
|
|
|
PTRTRIM_CP(*ki, *ki32, ki_paddr);
|
|
|
|
PTRTRIM_CP(*ki, *ki32, ki_addr);
|
|
|
|
PTRTRIM_CP(*ki, *ki32, ki_tracep);
|
|
|
|
PTRTRIM_CP(*ki, *ki32, ki_textvp);
|
|
|
|
PTRTRIM_CP(*ki, *ki32, ki_fd);
|
|
|
|
PTRTRIM_CP(*ki, *ki32, ki_vmspace);
|
|
|
|
PTRTRIM_CP(*ki, *ki32, ki_wchan);
|
|
|
|
CP(*ki, *ki32, ki_pid);
|
|
|
|
CP(*ki, *ki32, ki_ppid);
|
|
|
|
CP(*ki, *ki32, ki_pgid);
|
|
|
|
CP(*ki, *ki32, ki_tpgid);
|
|
|
|
CP(*ki, *ki32, ki_sid);
|
|
|
|
CP(*ki, *ki32, ki_tsid);
|
|
|
|
CP(*ki, *ki32, ki_jobc);
|
|
|
|
CP(*ki, *ki32, ki_tdev);
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
CP(*ki, *ki32, ki_tdev_freebsd11);
|
2010-04-21 19:32:00 +00:00
|
|
|
CP(*ki, *ki32, ki_siglist);
|
|
|
|
CP(*ki, *ki32, ki_sigmask);
|
|
|
|
CP(*ki, *ki32, ki_sigignore);
|
|
|
|
CP(*ki, *ki32, ki_sigcatch);
|
|
|
|
CP(*ki, *ki32, ki_uid);
|
|
|
|
CP(*ki, *ki32, ki_ruid);
|
|
|
|
CP(*ki, *ki32, ki_svuid);
|
|
|
|
CP(*ki, *ki32, ki_rgid);
|
|
|
|
CP(*ki, *ki32, ki_svgid);
|
|
|
|
CP(*ki, *ki32, ki_ngroups);
|
|
|
|
for (i = 0; i < KI_NGROUPS; i++)
|
|
|
|
CP(*ki, *ki32, ki_groups[i]);
|
|
|
|
CP(*ki, *ki32, ki_size);
|
|
|
|
CP(*ki, *ki32, ki_rssize);
|
|
|
|
CP(*ki, *ki32, ki_swrss);
|
|
|
|
CP(*ki, *ki32, ki_tsize);
|
|
|
|
CP(*ki, *ki32, ki_dsize);
|
|
|
|
CP(*ki, *ki32, ki_ssize);
|
|
|
|
CP(*ki, *ki32, ki_xstat);
|
|
|
|
CP(*ki, *ki32, ki_acflag);
|
|
|
|
CP(*ki, *ki32, ki_pctcpu);
|
|
|
|
CP(*ki, *ki32, ki_estcpu);
|
|
|
|
CP(*ki, *ki32, ki_slptime);
|
|
|
|
CP(*ki, *ki32, ki_swtime);
|
2012-05-27 05:24:53 +00:00
|
|
|
CP(*ki, *ki32, ki_cow);
|
2010-04-21 19:32:00 +00:00
|
|
|
CP(*ki, *ki32, ki_runtime);
|
|
|
|
TV_CP(*ki, *ki32, ki_start);
|
|
|
|
TV_CP(*ki, *ki32, ki_childtime);
|
|
|
|
CP(*ki, *ki32, ki_flag);
|
|
|
|
CP(*ki, *ki32, ki_kiflag);
|
|
|
|
CP(*ki, *ki32, ki_traceflag);
|
|
|
|
CP(*ki, *ki32, ki_stat);
|
|
|
|
CP(*ki, *ki32, ki_nice);
|
|
|
|
CP(*ki, *ki32, ki_lock);
|
|
|
|
CP(*ki, *ki32, ki_rqindex);
|
|
|
|
CP(*ki, *ki32, ki_oncpu);
|
|
|
|
CP(*ki, *ki32, ki_lastcpu);
|
2014-10-18 19:36:11 +00:00
|
|
|
|
|
|
|
/* XXX TODO: wrap cpu value as appropriate */
|
|
|
|
CP(*ki, *ki32, ki_oncpu_old);
|
|
|
|
CP(*ki, *ki32, ki_lastcpu_old);
|
|
|
|
|
2011-07-18 20:06:15 +00:00
|
|
|
bcopy(ki->ki_tdname, ki32->ki_tdname, TDNAMLEN + 1);
|
2010-04-21 19:32:00 +00:00
|
|
|
bcopy(ki->ki_wmesg, ki32->ki_wmesg, WMESGLEN + 1);
|
|
|
|
bcopy(ki->ki_login, ki32->ki_login, LOGNAMELEN + 1);
|
|
|
|
bcopy(ki->ki_lockname, ki32->ki_lockname, LOCKNAMELEN + 1);
|
|
|
|
bcopy(ki->ki_comm, ki32->ki_comm, COMMLEN + 1);
|
|
|
|
bcopy(ki->ki_emul, ki32->ki_emul, KI_EMULNAMELEN + 1);
|
2011-03-05 14:41:49 +00:00
|
|
|
bcopy(ki->ki_loginclass, ki32->ki_loginclass, LOGINCLASSLEN + 1);
|
2016-12-07 15:04:22 +00:00
|
|
|
bcopy(ki->ki_moretdname, ki32->ki_moretdname, MAXCOMLEN - TDNAMLEN + 1);
|
2014-08-28 08:41:11 +00:00
|
|
|
CP(*ki, *ki32, ki_tracer);
|
2013-09-19 18:53:42 +00:00
|
|
|
CP(*ki, *ki32, ki_flag2);
|
2013-08-26 23:48:21 +00:00
|
|
|
CP(*ki, *ki32, ki_fibnum);
|
2010-04-21 19:32:00 +00:00
|
|
|
CP(*ki, *ki32, ki_cr_flags);
|
|
|
|
CP(*ki, *ki32, ki_jid);
|
|
|
|
CP(*ki, *ki32, ki_numthreads);
|
|
|
|
CP(*ki, *ki32, ki_tid);
|
|
|
|
CP(*ki, *ki32, ki_pri);
|
|
|
|
freebsd32_rusage_out(&ki->ki_rusage, &ki32->ki_rusage);
|
|
|
|
freebsd32_rusage_out(&ki->ki_rusage_ch, &ki32->ki_rusage_ch);
|
|
|
|
PTRTRIM_CP(*ki, *ki32, ki_pcb);
|
|
|
|
PTRTRIM_CP(*ki, *ki32, ki_kstack);
|
|
|
|
PTRTRIM_CP(*ki, *ki32, ki_udata);
|
2017-07-14 21:13:05 +00:00
|
|
|
PTRTRIM_CP(*ki, *ki32, ki_tdaddr);
|
2010-04-21 19:32:00 +00:00
|
|
|
CP(*ki, *ki32, ki_sflag);
|
|
|
|
CP(*ki, *ki32, ki_tdflags);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2018-02-25 15:16:58 +00:00
|
|
|
static ssize_t
|
|
|
|
kern_proc_out_size(struct proc *p, int flags)
|
|
|
|
{
|
|
|
|
ssize_t size = 0;
|
|
|
|
|
|
|
|
PROC_LOCK_ASSERT(p, MA_OWNED);
|
|
|
|
|
|
|
|
if ((flags & KERN_PROC_NOTHREADS) != 0) {
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
if ((flags & KERN_PROC_MASK32) != 0) {
|
|
|
|
size += sizeof(struct kinfo_proc32);
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
size += sizeof(struct kinfo_proc);
|
|
|
|
} else {
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
if ((flags & KERN_PROC_MASK32) != 0)
|
|
|
|
size += sizeof(struct kinfo_proc32) * p->p_numthreads;
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
size += sizeof(struct kinfo_proc) * p->p_numthreads;
|
|
|
|
}
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
return (size);
|
|
|
|
}
|
|
|
|
|
2013-04-14 20:01:36 +00:00
|
|
|
int
|
|
|
|
kern_proc_out(struct proc *p, struct sbuf *sb, int flags)
|
1996-06-06 17:19:21 +00:00
|
|
|
{
|
2003-06-12 16:41:50 +00:00
|
|
|
struct thread *td;
|
2013-04-14 20:01:36 +00:00
|
|
|
struct kinfo_proc ki;
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
struct kinfo_proc32 ki32;
|
|
|
|
#endif
|
|
|
|
int error;
|
1996-06-06 17:19:21 +00:00
|
|
|
|
2002-04-09 20:10:46 +00:00
|
|
|
PROC_LOCK_ASSERT(p, MA_OWNED);
|
2009-02-18 21:52:13 +00:00
|
|
|
MPASS(FIRST_THREAD_IN_PROC(p) != NULL);
|
2003-06-12 16:41:50 +00:00
|
|
|
|
2013-04-14 20:01:36 +00:00
|
|
|
error = 0;
|
|
|
|
fill_kinfo_proc(p, &ki);
|
|
|
|
if ((flags & KERN_PROC_NOTHREADS) != 0) {
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
if ((flags & KERN_PROC_MASK32) != 0) {
|
|
|
|
freebsd32_kinfo_proc_out(&ki, &ki32);
|
2014-10-05 17:35:59 +00:00
|
|
|
if (sbuf_bcat(sb, &ki32, sizeof(ki32)) != 0)
|
|
|
|
error = ENOMEM;
|
2013-04-14 20:01:36 +00:00
|
|
|
} else
|
|
|
|
#endif
|
2014-10-05 17:35:59 +00:00
|
|
|
if (sbuf_bcat(sb, &ki, sizeof(ki)) != 0)
|
|
|
|
error = ENOMEM;
|
2013-04-14 20:01:36 +00:00
|
|
|
} else {
|
2009-02-18 21:52:13 +00:00
|
|
|
FOREACH_THREAD_IN_PROC(p, td) {
|
2013-04-14 20:01:36 +00:00
|
|
|
fill_kinfo_thread(td, &ki, 1);
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
if ((flags & KERN_PROC_MASK32) != 0) {
|
|
|
|
freebsd32_kinfo_proc_out(&ki, &ki32);
|
2014-10-05 17:35:59 +00:00
|
|
|
if (sbuf_bcat(sb, &ki32, sizeof(ki32)) != 0)
|
|
|
|
error = ENOMEM;
|
2013-04-14 20:01:36 +00:00
|
|
|
} else
|
|
|
|
#endif
|
2014-10-05 17:35:59 +00:00
|
|
|
if (sbuf_bcat(sb, &ki, sizeof(ki)) != 0)
|
|
|
|
error = ENOMEM;
|
|
|
|
if (error != 0)
|
2009-02-18 21:52:13 +00:00
|
|
|
break;
|
|
|
|
}
|
2003-06-12 16:41:50 +00:00
|
|
|
}
|
2002-04-09 20:10:46 +00:00
|
|
|
PROC_UNLOCK(p);
|
2013-04-14 20:01:36 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2017-11-11 18:02:23 +00:00
|
|
|
sysctl_out_proc(struct proc *p, struct sysctl_req *req, int flags)
|
2013-04-14 20:01:36 +00:00
|
|
|
{
|
|
|
|
struct sbuf sb;
|
|
|
|
struct kinfo_proc ki;
|
|
|
|
int error, error2;
|
|
|
|
|
2018-02-25 15:16:58 +00:00
|
|
|
if (req->oldptr == NULL)
|
|
|
|
return (SYSCTL_OUT(req, 0, kern_proc_out_size(p, flags)));
|
|
|
|
|
2013-04-14 20:01:36 +00:00
|
|
|
sbuf_new_for_sysctl(&sb, (char *)&ki, sizeof(ki), req);
|
2015-03-14 17:08:28 +00:00
|
|
|
sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
|
2013-04-14 20:01:36 +00:00
|
|
|
error = kern_proc_out(p, &sb, flags);
|
|
|
|
error2 = sbuf_finish(&sb);
|
|
|
|
sbuf_delete(&sb);
|
|
|
|
if (error != 0)
|
1996-06-06 17:19:21 +00:00
|
|
|
return (error);
|
2013-04-14 20:01:36 +00:00
|
|
|
else if (error2 != 0)
|
|
|
|
return (error2);
|
1996-06-06 17:19:21 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2018-11-21 18:56:15 +00:00
|
|
|
int
|
|
|
|
proc_iterate(int (*cb)(struct proc *, void *), void *cbarg)
|
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
int error, i, j;
|
|
|
|
|
|
|
|
for (i = 0; i < pidhashlock + 1; i++) {
|
|
|
|
sx_slock(&pidhashtbl_lock[i]);
|
|
|
|
for (j = i; j <= pidhash; j += pidhashlock + 1) {
|
|
|
|
LIST_FOREACH(p, &pidhashtbl[j], p_hash) {
|
|
|
|
if (p->p_state == PRS_NEW)
|
|
|
|
continue;
|
|
|
|
error = cb(p, cbarg);
|
|
|
|
PROC_LOCK_ASSERT(p, MA_NOTOWNED);
|
|
|
|
if (error != 0) {
|
|
|
|
sx_sunlock(&pidhashtbl_lock[i]);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sx_sunlock(&pidhashtbl_lock[i]);
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct kern_proc_out_args {
|
|
|
|
struct sysctl_req *req;
|
|
|
|
int flags;
|
|
|
|
int oid_number;
|
|
|
|
int *name;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
|
|
|
sysctl_kern_proc_iterate(struct proc *p, void *origarg)
|
|
|
|
{
|
|
|
|
struct kern_proc_out_args *arg = origarg;
|
|
|
|
int *name = arg->name;
|
|
|
|
int oid_number = arg->oid_number;
|
|
|
|
int flags = arg->flags;
|
|
|
|
struct sysctl_req *req = arg->req;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
PROC_LOCK(p);
|
|
|
|
|
|
|
|
KASSERT(p->p_ucred != NULL,
|
|
|
|
("process credential is NULL for non-NEW proc"));
|
|
|
|
/*
|
|
|
|
* Show a user only appropriate processes.
|
|
|
|
*/
|
|
|
|
if (p_cansee(curthread, p))
|
|
|
|
goto skip;
|
|
|
|
/*
|
|
|
|
* TODO - make more efficient (see notes below).
|
|
|
|
* do by session.
|
|
|
|
*/
|
|
|
|
switch (oid_number) {
|
|
|
|
|
|
|
|
case KERN_PROC_GID:
|
|
|
|
if (p->p_ucred->cr_gid != (gid_t)name[0])
|
|
|
|
goto skip;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KERN_PROC_PGRP:
|
|
|
|
/* could do this by traversing pgrp */
|
|
|
|
if (p->p_pgrp == NULL ||
|
|
|
|
p->p_pgrp->pg_id != (pid_t)name[0])
|
|
|
|
goto skip;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KERN_PROC_RGID:
|
|
|
|
if (p->p_ucred->cr_rgid != (gid_t)name[0])
|
|
|
|
goto skip;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KERN_PROC_SESSION:
|
|
|
|
if (p->p_session == NULL ||
|
|
|
|
p->p_session->s_sid != (pid_t)name[0])
|
|
|
|
goto skip;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KERN_PROC_TTY:
|
|
|
|
if ((p->p_flag & P_CONTROLT) == 0 ||
|
|
|
|
p->p_session == NULL)
|
|
|
|
goto skip;
|
|
|
|
/* XXX proctree_lock */
|
|
|
|
SESS_LOCK(p->p_session);
|
|
|
|
if (p->p_session->s_ttyp == NULL ||
|
|
|
|
tty_udev(p->p_session->s_ttyp) !=
|
|
|
|
(dev_t)name[0]) {
|
|
|
|
SESS_UNLOCK(p->p_session);
|
|
|
|
goto skip;
|
|
|
|
}
|
|
|
|
SESS_UNLOCK(p->p_session);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KERN_PROC_UID:
|
|
|
|
if (p->p_ucred->cr_uid != (uid_t)name[0])
|
|
|
|
goto skip;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KERN_PROC_RUID:
|
|
|
|
if (p->p_ucred->cr_ruid != (uid_t)name[0])
|
|
|
|
goto skip;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KERN_PROC_PROC:
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
error = sysctl_out_proc(p, req, flags);
|
|
|
|
PROC_LOCK_ASSERT(p, MA_NOTOWNED);
|
|
|
|
return (error);
|
|
|
|
skip:
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1995-11-14 09:16:27 +00:00
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_kern_proc(SYSCTL_HANDLER_ARGS)
|
1995-11-14 09:16:27 +00:00
|
|
|
{
|
2018-11-21 18:56:15 +00:00
|
|
|
struct kern_proc_out_args iterarg;
|
2011-12-17 22:18:26 +00:00
|
|
|
int *name = (int *)arg1;
|
1995-11-14 09:16:27 +00:00
|
|
|
u_int namelen = arg2;
|
|
|
|
struct proc *p;
|
2018-11-21 18:56:15 +00:00
|
|
|
int flags, oid_number;
|
1995-11-14 09:16:27 +00:00
|
|
|
int error = 0;
|
|
|
|
|
2004-02-22 17:54:32 +00:00
|
|
|
oid_number = oidp->oid_number;
|
|
|
|
if (oid_number != KERN_PROC_ALL &&
|
|
|
|
(oid_number & KERN_PROC_INC_THREAD) == 0)
|
|
|
|
flags = KERN_PROC_NOTHREADS;
|
|
|
|
else {
|
|
|
|
flags = 0;
|
|
|
|
oid_number &= ~KERN_PROC_INC_THREAD;
|
|
|
|
}
|
2013-04-14 20:01:36 +00:00
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
if (req->flags & SCTL_MASK32)
|
|
|
|
flags |= KERN_PROC_MASK32;
|
|
|
|
#endif
|
2004-02-22 17:54:32 +00:00
|
|
|
if (oid_number == KERN_PROC_PID) {
|
2011-12-17 22:18:26 +00:00
|
|
|
if (namelen != 1)
|
1996-06-06 17:19:21 +00:00
|
|
|
return (EINVAL);
|
2005-10-02 23:27:56 +00:00
|
|
|
error = sysctl_wire_old_buffer(req, 0);
|
|
|
|
if (error)
|
2011-12-17 22:18:26 +00:00
|
|
|
return (error);
|
2011-12-17 16:59:22 +00:00
|
|
|
error = pget((pid_t)name[0], PGET_CANSEE, &p);
|
2014-08-28 08:41:11 +00:00
|
|
|
if (error == 0)
|
2017-11-11 18:02:23 +00:00
|
|
|
error = sysctl_out_proc(p, req, flags);
|
1996-06-06 17:19:21 +00:00
|
|
|
return (error);
|
|
|
|
}
|
2003-09-19 14:16:50 +00:00
|
|
|
|
2004-02-22 17:54:32 +00:00
|
|
|
switch (oid_number) {
|
2003-09-19 14:16:50 +00:00
|
|
|
case KERN_PROC_ALL:
|
|
|
|
if (namelen != 0)
|
|
|
|
return (EINVAL);
|
|
|
|
break;
|
2003-10-15 03:11:46 +00:00
|
|
|
case KERN_PROC_PROC:
|
|
|
|
if (namelen != 0 && namelen != 1)
|
|
|
|
return (EINVAL);
|
|
|
|
break;
|
2003-09-19 14:16:50 +00:00
|
|
|
default:
|
|
|
|
if (namelen != 1)
|
|
|
|
return (EINVAL);
|
|
|
|
break;
|
|
|
|
}
|
2011-12-17 22:18:26 +00:00
|
|
|
|
2018-02-25 15:16:58 +00:00
|
|
|
if (req->oldptr == NULL) {
|
1996-06-06 17:19:21 +00:00
|
|
|
/* overestimate by 5 procs */
|
1995-11-14 09:16:27 +00:00
|
|
|
error = SYSCTL_OUT(req, 0, sizeof (struct kinfo_proc) * 5);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
2018-02-25 15:16:58 +00:00
|
|
|
} else {
|
|
|
|
error = sysctl_wire_old_buffer(req, 0);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
1995-11-14 09:16:27 +00:00
|
|
|
}
|
2018-11-21 18:56:15 +00:00
|
|
|
iterarg.flags = flags;
|
|
|
|
iterarg.oid_number = oid_number;
|
|
|
|
iterarg.req = req;
|
|
|
|
iterarg.name = name;
|
|
|
|
error = proc_iterate(sysctl_kern_proc_iterate, &iterarg);
|
2018-02-25 15:16:58 +00:00
|
|
|
return (error);
|
1995-11-14 09:16:27 +00:00
|
|
|
}
|
|
|
|
|
2002-03-28 18:12:27 +00:00
|
|
|
struct pargs *
|
|
|
|
pargs_alloc(int len)
|
|
|
|
{
|
|
|
|
struct pargs *pa;
|
|
|
|
|
2008-10-23 15:53:51 +00:00
|
|
|
pa = malloc(sizeof(struct pargs) + len, M_PARGS,
|
2003-02-19 05:47:46 +00:00
|
|
|
M_WAITOK);
|
2005-09-27 18:03:15 +00:00
|
|
|
refcount_init(&pa->ar_ref, 1);
|
2002-03-28 18:12:27 +00:00
|
|
|
pa->ar_length = len;
|
|
|
|
return (pa);
|
|
|
|
}
|
|
|
|
|
2008-07-25 11:55:32 +00:00
|
|
|
static void
|
2002-03-28 18:12:27 +00:00
|
|
|
pargs_free(struct pargs *pa)
|
|
|
|
{
|
|
|
|
|
2008-10-23 15:53:51 +00:00
|
|
|
free(pa, M_PARGS);
|
2002-03-28 18:12:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
pargs_hold(struct pargs *pa)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (pa == NULL)
|
|
|
|
return;
|
2005-09-27 18:03:15 +00:00
|
|
|
refcount_acquire(&pa->ar_ref);
|
2002-03-28 18:12:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
pargs_drop(struct pargs *pa)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (pa == NULL)
|
|
|
|
return;
|
2005-09-27 18:03:15 +00:00
|
|
|
if (refcount_release(&pa->ar_ref))
|
2002-03-28 18:12:27 +00:00
|
|
|
pargs_free(pa);
|
|
|
|
}
|
|
|
|
|
2011-11-22 20:40:18 +00:00
|
|
|
static int
|
|
|
|
proc_read_string(struct thread *td, struct proc *p, const char *sptr, char *buf,
|
|
|
|
size_t len)
|
|
|
|
{
|
2015-12-07 21:33:15 +00:00
|
|
|
ssize_t n;
|
2011-11-22 20:40:18 +00:00
|
|
|
|
|
|
|
/*
|
2015-12-07 21:33:15 +00:00
|
|
|
* This may return a short read if the string is shorter than the chunk
|
|
|
|
* and is aligned at the end of the page, and the following page is not
|
|
|
|
* mapped.
|
2011-11-22 20:40:18 +00:00
|
|
|
*/
|
2015-12-07 21:33:15 +00:00
|
|
|
n = proc_readmem(td, p, (vm_offset_t)sptr, buf, len);
|
|
|
|
if (n <= 0)
|
|
|
|
return (ENOMEM);
|
|
|
|
return (0);
|
2011-11-22 20:40:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define PROC_AUXV_MAX 256 /* Safety limit on auxv size. */
|
|
|
|
|
|
|
|
enum proc_vector_type {
|
|
|
|
PROC_ARG,
|
|
|
|
PROC_ENV,
|
|
|
|
PROC_AUX,
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
static int
|
|
|
|
get_proc_vector32(struct thread *td, struct proc *p, char ***proc_vectorp,
|
|
|
|
size_t *vsizep, enum proc_vector_type type)
|
|
|
|
{
|
|
|
|
struct freebsd32_ps_strings pss;
|
|
|
|
Elf32_Auxinfo aux;
|
|
|
|
vm_offset_t vptr, ptr;
|
|
|
|
uint32_t *proc_vector32;
|
|
|
|
char **proc_vector;
|
|
|
|
size_t vsize, size;
|
|
|
|
int i, error;
|
|
|
|
|
2015-12-07 21:33:15 +00:00
|
|
|
error = 0;
|
|
|
|
if (proc_readmem(td, p, (vm_offset_t)p->p_sysent->sv_psstrings, &pss,
|
|
|
|
sizeof(pss)) != sizeof(pss))
|
|
|
|
return (ENOMEM);
|
2011-11-22 20:40:18 +00:00
|
|
|
switch (type) {
|
|
|
|
case PROC_ARG:
|
|
|
|
vptr = (vm_offset_t)PTRIN(pss.ps_argvstr);
|
|
|
|
vsize = pss.ps_nargvstr;
|
|
|
|
if (vsize > ARG_MAX)
|
|
|
|
return (ENOEXEC);
|
|
|
|
size = vsize * sizeof(int32_t);
|
|
|
|
break;
|
|
|
|
case PROC_ENV:
|
|
|
|
vptr = (vm_offset_t)PTRIN(pss.ps_envstr);
|
|
|
|
vsize = pss.ps_nenvstr;
|
|
|
|
if (vsize > ARG_MAX)
|
|
|
|
return (ENOEXEC);
|
|
|
|
size = vsize * sizeof(int32_t);
|
|
|
|
break;
|
|
|
|
case PROC_AUX:
|
|
|
|
vptr = (vm_offset_t)PTRIN(pss.ps_envstr) +
|
|
|
|
(pss.ps_nenvstr + 1) * sizeof(int32_t);
|
|
|
|
if (vptr % 4 != 0)
|
|
|
|
return (ENOEXEC);
|
|
|
|
for (ptr = vptr, i = 0; i < PROC_AUXV_MAX; i++) {
|
2015-12-07 21:33:15 +00:00
|
|
|
if (proc_readmem(td, p, ptr, &aux, sizeof(aux)) !=
|
|
|
|
sizeof(aux))
|
|
|
|
return (ENOMEM);
|
2011-11-22 20:40:18 +00:00
|
|
|
if (aux.a_type == AT_NULL)
|
|
|
|
break;
|
|
|
|
ptr += sizeof(aux);
|
|
|
|
}
|
|
|
|
if (aux.a_type != AT_NULL)
|
|
|
|
return (ENOEXEC);
|
|
|
|
vsize = i + 1;
|
|
|
|
size = vsize * sizeof(aux);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
KASSERT(0, ("Wrong proc vector type: %d", type));
|
2011-11-23 08:11:04 +00:00
|
|
|
return (EINVAL);
|
2011-11-22 20:40:18 +00:00
|
|
|
}
|
|
|
|
proc_vector32 = malloc(size, M_TEMP, M_WAITOK);
|
2015-12-07 21:33:15 +00:00
|
|
|
if (proc_readmem(td, p, vptr, proc_vector32, size) != size) {
|
|
|
|
error = ENOMEM;
|
2011-11-22 20:40:18 +00:00
|
|
|
goto done;
|
2015-12-07 21:33:15 +00:00
|
|
|
}
|
2011-11-22 20:40:18 +00:00
|
|
|
if (type == PROC_AUX) {
|
|
|
|
*proc_vectorp = (char **)proc_vector32;
|
|
|
|
*vsizep = vsize;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
proc_vector = malloc(vsize * sizeof(char *), M_TEMP, M_WAITOK);
|
|
|
|
for (i = 0; i < (int)vsize; i++)
|
|
|
|
proc_vector[i] = PTRIN(proc_vector32[i]);
|
|
|
|
*proc_vectorp = proc_vector;
|
|
|
|
*vsizep = vsize;
|
|
|
|
done:
|
|
|
|
free(proc_vector32, M_TEMP);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int
|
|
|
|
get_proc_vector(struct thread *td, struct proc *p, char ***proc_vectorp,
|
|
|
|
size_t *vsizep, enum proc_vector_type type)
|
|
|
|
{
|
|
|
|
struct ps_strings pss;
|
|
|
|
Elf_Auxinfo aux;
|
|
|
|
vm_offset_t vptr, ptr;
|
|
|
|
char **proc_vector;
|
|
|
|
size_t vsize, size;
|
2015-12-07 21:33:15 +00:00
|
|
|
int i;
|
2011-11-22 20:40:18 +00:00
|
|
|
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
if (SV_PROC_FLAG(p, SV_ILP32) != 0)
|
|
|
|
return (get_proc_vector32(td, p, proc_vectorp, vsizep, type));
|
|
|
|
#endif
|
2015-12-07 21:33:15 +00:00
|
|
|
if (proc_readmem(td, p, (vm_offset_t)p->p_sysent->sv_psstrings, &pss,
|
|
|
|
sizeof(pss)) != sizeof(pss))
|
|
|
|
return (ENOMEM);
|
2011-11-22 20:40:18 +00:00
|
|
|
switch (type) {
|
|
|
|
case PROC_ARG:
|
|
|
|
vptr = (vm_offset_t)pss.ps_argvstr;
|
|
|
|
vsize = pss.ps_nargvstr;
|
|
|
|
if (vsize > ARG_MAX)
|
|
|
|
return (ENOEXEC);
|
|
|
|
size = vsize * sizeof(char *);
|
|
|
|
break;
|
|
|
|
case PROC_ENV:
|
|
|
|
vptr = (vm_offset_t)pss.ps_envstr;
|
|
|
|
vsize = pss.ps_nenvstr;
|
|
|
|
if (vsize > ARG_MAX)
|
|
|
|
return (ENOEXEC);
|
|
|
|
size = vsize * sizeof(char *);
|
|
|
|
break;
|
|
|
|
case PROC_AUX:
|
|
|
|
/*
|
|
|
|
* The aux array is just above env array on the stack. Check
|
|
|
|
* that the address is naturally aligned.
|
|
|
|
*/
|
|
|
|
vptr = (vm_offset_t)pss.ps_envstr + (pss.ps_nenvstr + 1)
|
|
|
|
* sizeof(char *);
|
|
|
|
#if __ELF_WORD_SIZE == 64
|
|
|
|
if (vptr % sizeof(uint64_t) != 0)
|
|
|
|
#else
|
|
|
|
if (vptr % sizeof(uint32_t) != 0)
|
|
|
|
#endif
|
|
|
|
return (ENOEXEC);
|
|
|
|
/*
|
|
|
|
* We count the array size reading the aux vectors from the
|
|
|
|
* stack until AT_NULL vector is returned. So (to keep the code
|
|
|
|
* simple) we read the process stack twice: the first time here
|
|
|
|
* to find the size and the second time when copying the vectors
|
|
|
|
* to the allocated proc_vector.
|
|
|
|
*/
|
|
|
|
for (ptr = vptr, i = 0; i < PROC_AUXV_MAX; i++) {
|
2015-12-07 21:33:15 +00:00
|
|
|
if (proc_readmem(td, p, ptr, &aux, sizeof(aux)) !=
|
|
|
|
sizeof(aux))
|
|
|
|
return (ENOMEM);
|
2011-11-22 20:40:18 +00:00
|
|
|
if (aux.a_type == AT_NULL)
|
|
|
|
break;
|
|
|
|
ptr += sizeof(aux);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If the PROC_AUXV_MAX entries are iterated over, and we have
|
|
|
|
* not reached AT_NULL, it is most likely we are reading wrong
|
|
|
|
* data: either the process doesn't have auxv array or data has
|
|
|
|
* been modified. Return the error in this case.
|
|
|
|
*/
|
|
|
|
if (aux.a_type != AT_NULL)
|
|
|
|
return (ENOEXEC);
|
|
|
|
vsize = i + 1;
|
|
|
|
size = vsize * sizeof(aux);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
KASSERT(0, ("Wrong proc vector type: %d", type));
|
2011-11-23 08:11:04 +00:00
|
|
|
return (EINVAL); /* In case we are built without INVARIANTS. */
|
2011-11-22 20:40:18 +00:00
|
|
|
}
|
|
|
|
proc_vector = malloc(size, M_TEMP, M_WAITOK);
|
2015-12-07 21:33:15 +00:00
|
|
|
if (proc_readmem(td, p, vptr, proc_vector, size) != size) {
|
2011-11-22 20:40:18 +00:00
|
|
|
free(proc_vector, M_TEMP);
|
2015-12-07 21:33:15 +00:00
|
|
|
return (ENOMEM);
|
2011-11-22 20:40:18 +00:00
|
|
|
}
|
|
|
|
*proc_vectorp = proc_vector;
|
|
|
|
*vsizep = vsize;
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define GET_PS_STRINGS_CHUNK_SZ 256 /* Chunk size (bytes) for ps_strings operations. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
get_ps_strings(struct thread *td, struct proc *p, struct sbuf *sb,
|
2012-01-15 18:47:24 +00:00
|
|
|
enum proc_vector_type type)
|
2011-11-22 20:40:18 +00:00
|
|
|
{
|
2012-01-15 18:47:24 +00:00
|
|
|
size_t done, len, nchr, vsize;
|
2011-11-22 20:40:18 +00:00
|
|
|
int error, i;
|
|
|
|
char **proc_vector, *sptr;
|
|
|
|
char pss_string[GET_PS_STRINGS_CHUNK_SZ];
|
|
|
|
|
|
|
|
PROC_ASSERT_HELD(p);
|
|
|
|
|
2012-01-15 18:47:24 +00:00
|
|
|
/*
|
|
|
|
* We are not going to read more than 2 * (PATH_MAX + ARG_MAX) bytes.
|
|
|
|
*/
|
|
|
|
nchr = 2 * (PATH_MAX + ARG_MAX);
|
2011-11-22 20:40:18 +00:00
|
|
|
|
|
|
|
error = get_proc_vector(td, p, &proc_vector, &vsize, type);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
for (done = 0, i = 0; i < (int)vsize && done < nchr; i++) {
|
|
|
|
/*
|
|
|
|
* The program may have scribbled into its argv array, e.g. to
|
|
|
|
* remove some arguments. If that has happened, break out
|
|
|
|
* before trying to read from NULL.
|
|
|
|
*/
|
|
|
|
if (proc_vector[i] == NULL)
|
|
|
|
break;
|
|
|
|
for (sptr = proc_vector[i]; ; sptr += GET_PS_STRINGS_CHUNK_SZ) {
|
|
|
|
error = proc_read_string(td, p, sptr, pss_string,
|
|
|
|
sizeof(pss_string));
|
|
|
|
if (error != 0)
|
|
|
|
goto done;
|
|
|
|
len = strnlen(pss_string, GET_PS_STRINGS_CHUNK_SZ);
|
|
|
|
if (done + len >= nchr)
|
|
|
|
len = nchr - done - 1;
|
|
|
|
sbuf_bcat(sb, pss_string, len);
|
|
|
|
if (len != GET_PS_STRINGS_CHUNK_SZ)
|
|
|
|
break;
|
|
|
|
done += GET_PS_STRINGS_CHUNK_SZ;
|
|
|
|
}
|
|
|
|
sbuf_bcat(sb, "", 1);
|
|
|
|
done += len + 1;
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
free(proc_vector, M_TEMP);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2012-01-15 18:47:24 +00:00
|
|
|
proc_getargv(struct thread *td, struct proc *p, struct sbuf *sb)
|
2011-11-22 20:40:18 +00:00
|
|
|
{
|
|
|
|
|
2012-01-15 18:47:24 +00:00
|
|
|
return (get_ps_strings(curthread, p, sb, PROC_ARG));
|
2011-11-22 20:40:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2012-01-15 18:47:24 +00:00
|
|
|
proc_getenvv(struct thread *td, struct proc *p, struct sbuf *sb)
|
2011-11-22 20:40:18 +00:00
|
|
|
{
|
|
|
|
|
2012-01-15 18:47:24 +00:00
|
|
|
return (get_ps_strings(curthread, p, sb, PROC_ENV));
|
2011-11-22 20:40:18 +00:00
|
|
|
}
|
|
|
|
|
2013-04-14 20:03:48 +00:00
|
|
|
int
|
|
|
|
proc_getauxv(struct thread *td, struct proc *p, struct sbuf *sb)
|
|
|
|
{
|
|
|
|
size_t vsize, size;
|
|
|
|
char **auxv;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = get_proc_vector(td, p, &auxv, &vsize, PROC_AUX);
|
|
|
|
if (error == 0) {
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
if (SV_PROC_FLAG(p, SV_ILP32) != 0)
|
|
|
|
size = vsize * sizeof(Elf32_Auxinfo);
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
size = vsize * sizeof(Elf_Auxinfo);
|
2014-10-05 17:35:59 +00:00
|
|
|
if (sbuf_bcat(sb, auxv, size) != 0)
|
|
|
|
error = ENOMEM;
|
2013-04-14 20:03:48 +00:00
|
|
|
free(auxv, M_TEMP);
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1999-11-16 20:31:58 +00:00
|
|
|
/*
|
|
|
|
* This sysctl allows a process to retrieve the argument list or process
|
|
|
|
* title for another process without groping around in the address space
|
|
|
|
* of the other process. It also allow a process to set its own "process
|
|
|
|
* title to a string of its own choice.
|
|
|
|
*/
|
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS)
|
1999-11-16 20:31:58 +00:00
|
|
|
{
|
2011-12-17 22:18:26 +00:00
|
|
|
int *name = (int *)arg1;
|
1999-11-16 20:31:58 +00:00
|
|
|
u_int namelen = arg2;
|
2003-03-12 20:17:40 +00:00
|
|
|
struct pargs *newpa, *pa;
|
1999-11-16 20:31:58 +00:00
|
|
|
struct proc *p;
|
2011-11-22 20:40:18 +00:00
|
|
|
struct sbuf sb;
|
2011-12-17 16:59:22 +00:00
|
|
|
int flags, error = 0, error2;
|
2017-11-11 22:39:33 +00:00
|
|
|
pid_t pid;
|
1999-11-16 20:31:58 +00:00
|
|
|
|
2011-12-17 22:18:26 +00:00
|
|
|
if (namelen != 1)
|
1999-11-16 20:31:58 +00:00
|
|
|
return (EINVAL);
|
|
|
|
|
2017-11-11 22:39:33 +00:00
|
|
|
pid = (pid_t)name[0];
|
|
|
|
/*
|
|
|
|
* If the query is for this process and it is single-threaded, there
|
|
|
|
* is nobody to modify pargs, thus we can just read.
|
|
|
|
*/
|
|
|
|
p = curproc;
|
2018-01-01 21:25:01 +00:00
|
|
|
if (pid == p->p_pid && p->p_numthreads == 1 && req->newptr == NULL &&
|
|
|
|
(pa = p->p_args) != NULL)
|
|
|
|
return (SYSCTL_OUT(req, pa->ar_args, pa->ar_length));
|
2017-11-11 22:39:33 +00:00
|
|
|
|
2011-12-17 16:59:22 +00:00
|
|
|
flags = PGET_CANSEE;
|
|
|
|
if (req->newptr != NULL)
|
|
|
|
flags |= PGET_ISCURRENT;
|
2017-11-11 22:39:33 +00:00
|
|
|
error = pget(pid, flags, &p);
|
2011-12-17 16:59:22 +00:00
|
|
|
if (error)
|
2003-07-17 22:44:41 +00:00
|
|
|
return (error);
|
1999-11-16 20:31:58 +00:00
|
|
|
|
2002-03-31 10:33:12 +00:00
|
|
|
pa = p->p_args;
|
2011-11-22 20:40:18 +00:00
|
|
|
if (pa != NULL) {
|
|
|
|
pargs_hold(pa);
|
|
|
|
PROC_UNLOCK(p);
|
2002-03-31 10:33:12 +00:00
|
|
|
error = SYSCTL_OUT(req, pa->ar_args, pa->ar_length);
|
2011-11-22 20:40:18 +00:00
|
|
|
pargs_drop(pa);
|
|
|
|
} else if ((p->p_flag & (P_WEXIT | P_SYSTEM)) == 0) {
|
|
|
|
_PHOLD(p);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req);
|
2015-03-22 21:18:44 +00:00
|
|
|
sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
|
2012-01-15 18:47:24 +00:00
|
|
|
error = proc_getargv(curthread, p, &sb);
|
2011-11-22 20:40:18 +00:00
|
|
|
error2 = sbuf_finish(&sb);
|
|
|
|
PRELE(p);
|
|
|
|
sbuf_delete(&sb);
|
|
|
|
if (error == 0 && error2 != 0)
|
|
|
|
error = error2;
|
|
|
|
} else {
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
}
|
2003-03-12 20:17:40 +00:00
|
|
|
if (error != 0 || req->newptr == NULL)
|
1999-11-16 20:31:58 +00:00
|
|
|
return (error);
|
|
|
|
|
2017-11-13 07:47:43 +00:00
|
|
|
if (req->newlen > ps_arg_cache_limit - sizeof(struct pargs))
|
2003-03-12 20:17:40 +00:00
|
|
|
return (ENOMEM);
|
2018-07-04 13:22:48 +00:00
|
|
|
|
|
|
|
if (req->newlen == 0) {
|
|
|
|
/*
|
|
|
|
* Clear the argument pointer, so that we'll fetch arguments
|
|
|
|
* with proc_getargv() until further notice.
|
|
|
|
*/
|
|
|
|
newpa = NULL;
|
|
|
|
} else {
|
|
|
|
newpa = pargs_alloc(req->newlen);
|
|
|
|
error = SYSCTL_IN(req, newpa->ar_args, req->newlen);
|
|
|
|
if (error != 0) {
|
|
|
|
pargs_free(newpa);
|
|
|
|
return (error);
|
|
|
|
}
|
2003-03-12 16:14:55 +00:00
|
|
|
}
|
2001-04-24 00:51:53 +00:00
|
|
|
PROC_LOCK(p);
|
2001-06-20 23:10:06 +00:00
|
|
|
pa = p->p_args;
|
2003-03-12 16:14:55 +00:00
|
|
|
p->p_args = newpa;
|
2001-03-07 03:28:50 +00:00
|
|
|
PROC_UNLOCK(p);
|
2002-03-27 21:36:18 +00:00
|
|
|
pargs_drop(pa);
|
2003-03-12 16:14:55 +00:00
|
|
|
return (0);
|
1999-11-16 20:31:58 +00:00
|
|
|
}
|
1996-06-06 17:19:21 +00:00
|
|
|
|
2011-11-22 20:40:18 +00:00
|
|
|
/*
|
|
|
|
* This sysctl allows a process to retrieve environment of another process.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
sysctl_kern_proc_env(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
2011-12-17 22:18:26 +00:00
|
|
|
int *name = (int *)arg1;
|
2011-11-22 20:40:18 +00:00
|
|
|
u_int namelen = arg2;
|
|
|
|
struct proc *p;
|
|
|
|
struct sbuf sb;
|
|
|
|
int error, error2;
|
|
|
|
|
|
|
|
if (namelen != 1)
|
|
|
|
return (EINVAL);
|
|
|
|
|
2011-12-17 16:59:22 +00:00
|
|
|
error = pget((pid_t)name[0], PGET_WANTREAD, &p);
|
|
|
|
if (error != 0)
|
2011-11-22 20:40:18 +00:00
|
|
|
return (error);
|
|
|
|
if ((p->p_flag & P_SYSTEM) != 0) {
|
2011-12-17 16:59:22 +00:00
|
|
|
PRELE(p);
|
2011-11-22 20:40:18 +00:00
|
|
|
return (0);
|
|
|
|
}
|
2011-12-17 16:59:22 +00:00
|
|
|
|
2011-11-22 20:40:18 +00:00
|
|
|
sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req);
|
2015-03-22 21:18:44 +00:00
|
|
|
sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
|
2012-01-15 18:47:24 +00:00
|
|
|
error = proc_getenvv(curthread, p, &sb);
|
2011-11-22 20:40:18 +00:00
|
|
|
error2 = sbuf_finish(&sb);
|
|
|
|
PRELE(p);
|
|
|
|
sbuf_delete(&sb);
|
|
|
|
return (error != 0 ? error : error2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This sysctl allows a process to retrieve ELF auxiliary vector of
|
|
|
|
* another process.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
sysctl_kern_proc_auxv(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
2011-12-17 22:18:26 +00:00
|
|
|
int *name = (int *)arg1;
|
2011-11-22 20:40:18 +00:00
|
|
|
u_int namelen = arg2;
|
|
|
|
struct proc *p;
|
2013-04-14 20:03:48 +00:00
|
|
|
struct sbuf sb;
|
|
|
|
int error, error2;
|
2011-11-22 20:40:18 +00:00
|
|
|
|
|
|
|
if (namelen != 1)
|
|
|
|
return (EINVAL);
|
|
|
|
|
2011-12-17 16:59:22 +00:00
|
|
|
error = pget((pid_t)name[0], PGET_WANTREAD, &p);
|
|
|
|
if (error != 0)
|
2011-11-22 20:40:18 +00:00
|
|
|
return (error);
|
|
|
|
if ((p->p_flag & P_SYSTEM) != 0) {
|
2011-12-17 16:59:22 +00:00
|
|
|
PRELE(p);
|
2011-11-22 20:40:18 +00:00
|
|
|
return (0);
|
|
|
|
}
|
2013-04-14 20:03:48 +00:00
|
|
|
sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req);
|
2015-03-14 17:08:28 +00:00
|
|
|
sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
|
2013-04-14 20:03:48 +00:00
|
|
|
error = proc_getauxv(curthread, p, &sb);
|
|
|
|
error2 = sbuf_finish(&sb);
|
|
|
|
PRELE(p);
|
|
|
|
sbuf_delete(&sb);
|
|
|
|
return (error != 0 ? error : error2);
|
2011-11-22 20:40:18 +00:00
|
|
|
}
|
|
|
|
|
2005-04-18 02:10:37 +00:00
|
|
|
/*
|
|
|
|
* This sysctl allows a process to retrieve the path of the executable for
|
|
|
|
* itself or another process.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
sysctl_kern_proc_pathname(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
pid_t *pidp = (pid_t *)arg1;
|
|
|
|
unsigned int arglen = arg2;
|
|
|
|
struct proc *p;
|
|
|
|
struct vnode *vp;
|
|
|
|
char *retbuf, *freebuf;
|
2012-10-22 17:50:54 +00:00
|
|
|
int error;
|
2005-04-18 02:10:37 +00:00
|
|
|
|
|
|
|
if (arglen != 1)
|
|
|
|
return (EINVAL);
|
|
|
|
if (*pidp == -1) { /* -1 means this process */
|
|
|
|
p = req->td->td_proc;
|
|
|
|
} else {
|
2011-12-17 16:59:22 +00:00
|
|
|
error = pget(*pidp, PGET_CANSEE, &p);
|
|
|
|
if (error != 0)
|
2005-04-18 02:10:37 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
vp = p->p_textvp;
|
2007-11-20 18:03:09 +00:00
|
|
|
if (vp == NULL) {
|
|
|
|
if (*pidp != -1)
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
return (0);
|
|
|
|
}
|
2005-04-18 02:10:37 +00:00
|
|
|
vref(vp);
|
|
|
|
if (*pidp != -1)
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
error = vn_fullpath(req->td, vp, &retbuf, &freebuf);
|
|
|
|
vrele(vp);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
error = SYSCTL_OUT(req, retbuf, strlen(retbuf) + 1);
|
|
|
|
free(freebuf, M_TEMP);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2003-07-12 02:00:16 +00:00
|
|
|
static int
|
|
|
|
sysctl_kern_proc_sv_name(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
char *sv_name;
|
|
|
|
int *name;
|
|
|
|
int namelen;
|
2003-07-17 22:44:41 +00:00
|
|
|
int error;
|
2003-07-12 02:00:16 +00:00
|
|
|
|
|
|
|
namelen = arg2;
|
2011-12-17 22:18:26 +00:00
|
|
|
if (namelen != 1)
|
2003-07-12 02:00:16 +00:00
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
name = (int *)arg1;
|
2011-12-17 16:59:22 +00:00
|
|
|
error = pget((pid_t)name[0], PGET_CANSEE, &p);
|
|
|
|
if (error != 0)
|
2003-07-17 22:44:41 +00:00
|
|
|
return (error);
|
2003-07-12 02:00:16 +00:00
|
|
|
sv_name = p->p_sysent->sv_name;
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
return (sysctl_handle_string(oidp, sv_name, 0, req));
|
|
|
|
}
|
|
|
|
|
2008-12-02 06:50:26 +00:00
|
|
|
#ifdef KINFO_OVMENTRY_SIZE
|
|
|
|
CTASSERT(sizeof(struct kinfo_ovmentry) == KINFO_OVMENTRY_SIZE);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef COMPAT_FREEBSD7
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
static int
|
2008-12-02 06:50:26 +00:00
|
|
|
sysctl_kern_proc_ovmmap(SYSCTL_HANDLER_ARGS)
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
{
|
|
|
|
vm_map_entry_t entry, tmp_entry;
|
|
|
|
unsigned int last_timestamp;
|
|
|
|
char *fullpath, *freepath;
|
2008-12-02 06:50:26 +00:00
|
|
|
struct kinfo_ovmentry *kve;
|
2008-10-31 05:43:19 +00:00
|
|
|
struct vattr va;
|
|
|
|
struct ucred *cred;
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
int error, *name;
|
|
|
|
struct vnode *vp;
|
|
|
|
struct proc *p;
|
|
|
|
vm_map_t map;
|
2008-12-12 12:12:36 +00:00
|
|
|
struct vmspace *vm;
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
|
|
|
|
name = (int *)arg1;
|
2011-12-17 16:59:22 +00:00
|
|
|
error = pget((pid_t)name[0], PGET_WANTREAD, &p);
|
|
|
|
if (error != 0)
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
return (error);
|
2008-12-12 12:12:36 +00:00
|
|
|
vm = vmspace_acquire_ref(p);
|
|
|
|
if (vm == NULL) {
|
|
|
|
PRELE(p);
|
|
|
|
return (ESRCH);
|
|
|
|
}
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
kve = malloc(sizeof(*kve), M_TEMP, M_WAITOK);
|
|
|
|
|
2011-11-21 12:21:00 +00:00
|
|
|
map = &vm->vm_map;
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
vm_map_lock_read(map);
|
|
|
|
for (entry = map->header.next; entry != &map->header;
|
|
|
|
entry = entry->next) {
|
|
|
|
vm_object_t obj, tobj, lobj;
|
|
|
|
vm_offset_t addr;
|
|
|
|
|
|
|
|
if (entry->eflags & MAP_ENTRY_IS_SUB_MAP)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
bzero(kve, sizeof(*kve));
|
|
|
|
kve->kve_structsize = sizeof(*kve);
|
|
|
|
|
|
|
|
kve->kve_private_resident = 0;
|
|
|
|
obj = entry->object.vm_object;
|
|
|
|
if (obj != NULL) {
|
2013-04-08 19:58:32 +00:00
|
|
|
VM_OBJECT_RLOCK(obj);
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
if (obj->shadow_count == 1)
|
|
|
|
kve->kve_private_resident =
|
|
|
|
obj->resident_page_count;
|
|
|
|
}
|
|
|
|
kve->kve_resident = 0;
|
|
|
|
addr = entry->start;
|
|
|
|
while (addr < entry->end) {
|
|
|
|
if (pmap_extract(map->pmap, addr))
|
|
|
|
kve->kve_resident++;
|
|
|
|
addr += PAGE_SIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (lobj = tobj = obj; tobj; tobj = tobj->backing_object) {
|
2018-01-04 21:59:34 +00:00
|
|
|
if (tobj != obj) {
|
2013-04-08 19:58:32 +00:00
|
|
|
VM_OBJECT_RLOCK(tobj);
|
2018-01-04 21:59:34 +00:00
|
|
|
kve->kve_offset += tobj->backing_object_offset;
|
|
|
|
}
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
if (lobj != obj)
|
2013-04-08 19:58:32 +00:00
|
|
|
VM_OBJECT_RUNLOCK(lobj);
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
lobj = tobj;
|
|
|
|
}
|
|
|
|
|
2008-12-08 12:29:30 +00:00
|
|
|
kve->kve_start = (void*)entry->start;
|
|
|
|
kve->kve_end = (void*)entry->end;
|
2018-01-04 21:59:34 +00:00
|
|
|
kve->kve_offset += (off_t)entry->offset;
|
2008-12-08 12:29:30 +00:00
|
|
|
|
|
|
|
if (entry->protection & VM_PROT_READ)
|
|
|
|
kve->kve_protection |= KVME_PROT_READ;
|
|
|
|
if (entry->protection & VM_PROT_WRITE)
|
|
|
|
kve->kve_protection |= KVME_PROT_WRITE;
|
|
|
|
if (entry->protection & VM_PROT_EXECUTE)
|
|
|
|
kve->kve_protection |= KVME_PROT_EXEC;
|
|
|
|
|
|
|
|
if (entry->eflags & MAP_ENTRY_COW)
|
|
|
|
kve->kve_flags |= KVME_FLAG_COW;
|
|
|
|
if (entry->eflags & MAP_ENTRY_NEEDS_COPY)
|
|
|
|
kve->kve_flags |= KVME_FLAG_NEEDS_COPY;
|
2010-05-27 08:10:12 +00:00
|
|
|
if (entry->eflags & MAP_ENTRY_NOCOREDUMP)
|
|
|
|
kve->kve_flags |= KVME_FLAG_NOCOREDUMP;
|
2008-12-08 12:29:30 +00:00
|
|
|
|
|
|
|
last_timestamp = map->timestamp;
|
|
|
|
vm_map_unlock_read(map);
|
|
|
|
|
2008-10-31 05:43:19 +00:00
|
|
|
kve->kve_fileid = 0;
|
|
|
|
kve->kve_fsid = 0;
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
freepath = NULL;
|
|
|
|
fullpath = "";
|
|
|
|
if (lobj) {
|
2018-11-30 04:59:43 +00:00
|
|
|
kve->kve_type = vm_object_kvme_type(lobj, &vp);
|
|
|
|
if (kve->kve_type == KVME_TYPE_MGTDEVICE)
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
kve->kve_type = KVME_TYPE_UNKNOWN;
|
2018-11-30 04:59:43 +00:00
|
|
|
if (vp != NULL)
|
|
|
|
vref(vp);
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
if (lobj != obj)
|
2013-04-08 19:58:32 +00:00
|
|
|
VM_OBJECT_RUNLOCK(lobj);
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
|
|
|
|
kve->kve_ref_count = obj->ref_count;
|
|
|
|
kve->kve_shadow_count = obj->shadow_count;
|
2013-04-08 19:58:32 +00:00
|
|
|
VM_OBJECT_RUNLOCK(obj);
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
if (vp != NULL) {
|
|
|
|
vn_fullpath(curthread, vp, &fullpath,
|
|
|
|
&freepath);
|
2008-10-31 05:43:19 +00:00
|
|
|
cred = curthread->td_ucred;
|
2008-11-04 19:04:01 +00:00
|
|
|
vn_lock(vp, LK_SHARED | LK_RETRY);
|
2008-10-31 05:43:19 +00:00
|
|
|
if (VOP_GETATTR(vp, &va, cred) == 0) {
|
|
|
|
kve->kve_fileid = va.va_fileid;
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
/* truncate */
|
2008-10-31 05:43:19 +00:00
|
|
|
kve->kve_fsid = va.va_fsid;
|
|
|
|
}
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
vput(vp);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
kve->kve_type = KVME_TYPE_NONE;
|
|
|
|
kve->kve_ref_count = 0;
|
|
|
|
kve->kve_shadow_count = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
strlcpy(kve->kve_path, fullpath, sizeof(kve->kve_path));
|
|
|
|
if (freepath != NULL)
|
|
|
|
free(freepath, M_TEMP);
|
|
|
|
|
|
|
|
error = SYSCTL_OUT(req, kve, sizeof(*kve));
|
|
|
|
vm_map_lock_read(map);
|
|
|
|
if (error)
|
|
|
|
break;
|
2008-12-29 12:45:11 +00:00
|
|
|
if (last_timestamp != map->timestamp) {
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
vm_map_lookup_entry(map, addr - 1, &tmp_entry);
|
|
|
|
entry = tmp_entry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
vm_map_unlock_read(map);
|
2008-12-12 12:12:36 +00:00
|
|
|
vmspace_free(vm);
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
PRELE(p);
|
|
|
|
free(kve, M_TEMP);
|
|
|
|
return (error);
|
|
|
|
}
|
2008-12-02 06:50:26 +00:00
|
|
|
#endif /* COMPAT_FREEBSD7 */
|
|
|
|
|
|
|
|
#ifdef KINFO_VMENTRY_SIZE
|
|
|
|
CTASSERT(sizeof(struct kinfo_vmentry) == KINFO_VMENTRY_SIZE);
|
|
|
|
#endif
|
|
|
|
|
2017-12-28 13:16:32 +00:00
|
|
|
void
|
2014-07-15 19:57:03 +00:00
|
|
|
kern_proc_vmmap_resident(vm_map_t map, vm_map_entry_t entry,
|
2017-12-28 13:16:32 +00:00
|
|
|
int *resident_count, bool *super)
|
2014-07-15 19:57:03 +00:00
|
|
|
{
|
|
|
|
vm_object_t obj, tobj;
|
|
|
|
vm_page_t m, m_adv;
|
|
|
|
vm_offset_t addr;
|
|
|
|
vm_paddr_t locked_pa;
|
|
|
|
vm_pindex_t pi, pi_adv, pindex;
|
|
|
|
|
2017-12-28 13:16:32 +00:00
|
|
|
*super = false;
|
|
|
|
*resident_count = 0;
|
|
|
|
if (vmmap_skip_res_cnt)
|
|
|
|
return;
|
|
|
|
|
2014-07-15 19:57:03 +00:00
|
|
|
locked_pa = 0;
|
|
|
|
obj = entry->object.vm_object;
|
|
|
|
addr = entry->start;
|
|
|
|
m_adv = NULL;
|
2014-07-29 01:46:31 +00:00
|
|
|
pi = OFF_TO_IDX(entry->offset);
|
2014-07-15 19:57:03 +00:00
|
|
|
for (; addr < entry->end; addr += IDX_TO_OFF(pi_adv), pi += pi_adv) {
|
|
|
|
if (m_adv != NULL) {
|
|
|
|
m = m_adv;
|
|
|
|
} else {
|
2017-03-14 19:39:17 +00:00
|
|
|
pi_adv = atop(entry->end - addr);
|
2014-07-15 19:57:03 +00:00
|
|
|
pindex = pi;
|
|
|
|
for (tobj = obj;; tobj = tobj->backing_object) {
|
|
|
|
m = vm_page_find_least(tobj, pindex);
|
|
|
|
if (m != NULL) {
|
|
|
|
if (m->pindex == pindex)
|
|
|
|
break;
|
|
|
|
if (pi_adv > m->pindex - pindex) {
|
|
|
|
pi_adv = m->pindex - pindex;
|
|
|
|
m_adv = m;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (tobj->backing_object == NULL)
|
|
|
|
goto next;
|
|
|
|
pindex += OFF_TO_IDX(tobj->
|
|
|
|
backing_object_offset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
m_adv = NULL;
|
|
|
|
if (m->psind != 0 && addr + pagesizes[1] <= entry->end &&
|
|
|
|
(addr & (pagesizes[1] - 1)) == 0 &&
|
|
|
|
(pmap_mincore(map->pmap, addr, &locked_pa) &
|
|
|
|
MINCORE_SUPER) != 0) {
|
2017-12-28 13:16:32 +00:00
|
|
|
*super = true;
|
2017-03-14 19:39:17 +00:00
|
|
|
pi_adv = atop(pagesizes[1]);
|
2014-07-15 19:57:03 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We do not test the found page on validity.
|
|
|
|
* Either the page is busy and being paged in,
|
|
|
|
* or it was invalidated. The first case
|
|
|
|
* should be counted as resident, the second
|
|
|
|
* is not so clear; we do account both.
|
|
|
|
*/
|
|
|
|
pi_adv = 1;
|
|
|
|
}
|
2017-12-28 13:16:32 +00:00
|
|
|
*resident_count += pi_adv;
|
2014-07-15 19:57:03 +00:00
|
|
|
next:;
|
|
|
|
}
|
|
|
|
PA_UNLOCK_COND(locked_pa);
|
|
|
|
}
|
|
|
|
|
2013-04-14 20:01:36 +00:00
|
|
|
/*
|
|
|
|
* Must be called with the process locked and will return unlocked.
|
|
|
|
*/
|
|
|
|
int
|
Fix core corruption caused by race in note_procstat_vmmap
This fix is spiritually similar to r287442 and was discovered thanks to
the KASSERT added in that revision.
NT_PROCSTAT_VMMAP output length, when packing kinfo structs, is tied to
the length of filenames corresponding to vnodes in the process' vm map
via vn_fullpath. As vnodes may move during coredump, this is racy.
We do not remove the race, only prevent it from causing coredump
corruption.
- Add a sysctl, kern.coredump_pack_vmmapinfo, to allow users to disable
kinfo packing for PROCSTAT_VMMAP notes. This avoids VMMAP corruption
and truncation, even if names change, at the cost of up to PATH_MAX
bytes per mapped object. The new sysctl is documented in core.5.
- Fix note_procstat_vmmap to self-limit in the second pass. This
addresses corruption, at the cost of sometimes producing a truncated
result.
- Fix PROCSTAT_VMMAP consumers libutil (and libprocstat, via copy-paste)
to grok the new zero padding.
Reported by: pho (https://people.freebsd.org/~pho/stress/log/datamove4-2.txt)
Relnotes: yes
Sponsored by: EMC / Isilon Storage Division
Differential Revision: https://reviews.freebsd.org/D3824
2015-10-06 18:07:00 +00:00
|
|
|
kern_proc_vmmap_out(struct proc *p, struct sbuf *sb, ssize_t maxlen, int flags)
|
2008-12-02 06:50:26 +00:00
|
|
|
{
|
|
|
|
vm_map_entry_t entry, tmp_entry;
|
2014-07-09 19:11:57 +00:00
|
|
|
struct vattr va;
|
|
|
|
vm_map_t map;
|
|
|
|
vm_object_t obj, tobj, lobj;
|
2008-12-02 06:50:26 +00:00
|
|
|
char *fullpath, *freepath;
|
|
|
|
struct kinfo_vmentry *kve;
|
|
|
|
struct ucred *cred;
|
|
|
|
struct vnode *vp;
|
2008-12-12 12:12:36 +00:00
|
|
|
struct vmspace *vm;
|
2014-07-09 19:11:57 +00:00
|
|
|
vm_offset_t addr;
|
|
|
|
unsigned int last_timestamp;
|
|
|
|
int error;
|
2017-12-28 13:16:32 +00:00
|
|
|
bool super;
|
2008-12-02 06:50:26 +00:00
|
|
|
|
2013-04-14 20:01:36 +00:00
|
|
|
PROC_LOCK_ASSERT(p, MA_OWNED);
|
|
|
|
|
|
|
|
_PHOLD(p);
|
|
|
|
PROC_UNLOCK(p);
|
2008-12-12 12:12:36 +00:00
|
|
|
vm = vmspace_acquire_ref(p);
|
|
|
|
if (vm == NULL) {
|
|
|
|
PRELE(p);
|
|
|
|
return (ESRCH);
|
|
|
|
}
|
Fix core corruption caused by race in note_procstat_vmmap
This fix is spiritually similar to r287442 and was discovered thanks to
the KASSERT added in that revision.
NT_PROCSTAT_VMMAP output length, when packing kinfo structs, is tied to
the length of filenames corresponding to vnodes in the process' vm map
via vn_fullpath. As vnodes may move during coredump, this is racy.
We do not remove the race, only prevent it from causing coredump
corruption.
- Add a sysctl, kern.coredump_pack_vmmapinfo, to allow users to disable
kinfo packing for PROCSTAT_VMMAP notes. This avoids VMMAP corruption
and truncation, even if names change, at the cost of up to PATH_MAX
bytes per mapped object. The new sysctl is documented in core.5.
- Fix note_procstat_vmmap to self-limit in the second pass. This
addresses corruption, at the cost of sometimes producing a truncated
result.
- Fix PROCSTAT_VMMAP consumers libutil (and libprocstat, via copy-paste)
to grok the new zero padding.
Reported by: pho (https://people.freebsd.org/~pho/stress/log/datamove4-2.txt)
Relnotes: yes
Sponsored by: EMC / Isilon Storage Division
Differential Revision: https://reviews.freebsd.org/D3824
2015-10-06 18:07:00 +00:00
|
|
|
kve = malloc(sizeof(*kve), M_TEMP, M_WAITOK | M_ZERO);
|
2008-12-02 06:50:26 +00:00
|
|
|
|
2013-04-14 20:01:36 +00:00
|
|
|
error = 0;
|
2011-11-21 12:21:00 +00:00
|
|
|
map = &vm->vm_map;
|
2008-12-02 06:50:26 +00:00
|
|
|
vm_map_lock_read(map);
|
|
|
|
for (entry = map->header.next; entry != &map->header;
|
|
|
|
entry = entry->next) {
|
|
|
|
if (entry->eflags & MAP_ENTRY_IS_SUB_MAP)
|
|
|
|
continue;
|
|
|
|
|
2014-07-10 11:20:24 +00:00
|
|
|
addr = entry->end;
|
2008-12-02 06:50:26 +00:00
|
|
|
bzero(kve, sizeof(*kve));
|
|
|
|
obj = entry->object.vm_object;
|
|
|
|
if (obj != NULL) {
|
2014-07-09 19:11:57 +00:00
|
|
|
for (tobj = obj; tobj != NULL;
|
|
|
|
tobj = tobj->backing_object) {
|
|
|
|
VM_OBJECT_RLOCK(tobj);
|
2018-01-04 21:59:34 +00:00
|
|
|
kve->kve_offset += tobj->backing_object_offset;
|
2014-07-09 19:11:57 +00:00
|
|
|
lobj = tobj;
|
|
|
|
}
|
2014-07-15 19:49:00 +00:00
|
|
|
if (obj->backing_object == NULL)
|
2008-12-02 06:50:26 +00:00
|
|
|
kve->kve_private_resident =
|
|
|
|
obj->resident_page_count;
|
2017-12-28 13:16:32 +00:00
|
|
|
kern_proc_vmmap_resident(map, entry,
|
|
|
|
&kve->kve_resident, &super);
|
|
|
|
if (super)
|
|
|
|
kve->kve_flags |= KVME_FLAG_SUPER;
|
2014-07-09 19:11:57 +00:00
|
|
|
for (tobj = obj; tobj != NULL;
|
|
|
|
tobj = tobj->backing_object) {
|
|
|
|
if (tobj != obj && tobj != lobj)
|
|
|
|
VM_OBJECT_RUNLOCK(tobj);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
lobj = NULL;
|
2008-12-02 06:50:26 +00:00
|
|
|
}
|
|
|
|
|
2008-12-08 12:29:30 +00:00
|
|
|
kve->kve_start = entry->start;
|
|
|
|
kve->kve_end = entry->end;
|
2018-01-04 21:59:34 +00:00
|
|
|
kve->kve_offset += entry->offset;
|
2008-12-08 12:29:30 +00:00
|
|
|
|
|
|
|
if (entry->protection & VM_PROT_READ)
|
|
|
|
kve->kve_protection |= KVME_PROT_READ;
|
|
|
|
if (entry->protection & VM_PROT_WRITE)
|
|
|
|
kve->kve_protection |= KVME_PROT_WRITE;
|
|
|
|
if (entry->protection & VM_PROT_EXECUTE)
|
|
|
|
kve->kve_protection |= KVME_PROT_EXEC;
|
|
|
|
|
|
|
|
if (entry->eflags & MAP_ENTRY_COW)
|
|
|
|
kve->kve_flags |= KVME_FLAG_COW;
|
|
|
|
if (entry->eflags & MAP_ENTRY_NEEDS_COPY)
|
|
|
|
kve->kve_flags |= KVME_FLAG_NEEDS_COPY;
|
2010-05-27 08:10:12 +00:00
|
|
|
if (entry->eflags & MAP_ENTRY_NOCOREDUMP)
|
|
|
|
kve->kve_flags |= KVME_FLAG_NOCOREDUMP;
|
2012-07-16 09:38:19 +00:00
|
|
|
if (entry->eflags & MAP_ENTRY_GROWS_UP)
|
|
|
|
kve->kve_flags |= KVME_FLAG_GROWS_UP;
|
|
|
|
if (entry->eflags & MAP_ENTRY_GROWS_DOWN)
|
|
|
|
kve->kve_flags |= KVME_FLAG_GROWS_DOWN;
|
2019-03-05 19:45:37 +00:00
|
|
|
if (entry->eflags & MAP_ENTRY_USER_WIRED)
|
|
|
|
kve->kve_flags |= KVME_FLAG_USER_WIRED;
|
2008-12-08 12:29:30 +00:00
|
|
|
|
|
|
|
last_timestamp = map->timestamp;
|
|
|
|
vm_map_unlock_read(map);
|
|
|
|
|
2008-12-02 06:50:26 +00:00
|
|
|
freepath = NULL;
|
|
|
|
fullpath = "";
|
2014-07-09 19:11:57 +00:00
|
|
|
if (lobj != NULL) {
|
2018-11-30 04:59:43 +00:00
|
|
|
kve->kve_type = vm_object_kvme_type(lobj, &vp);
|
|
|
|
if (vp != NULL)
|
2008-12-02 06:50:26 +00:00
|
|
|
vref(vp);
|
|
|
|
if (lobj != obj)
|
2013-04-08 19:58:32 +00:00
|
|
|
VM_OBJECT_RUNLOCK(lobj);
|
2008-12-02 06:50:26 +00:00
|
|
|
|
|
|
|
kve->kve_ref_count = obj->ref_count;
|
|
|
|
kve->kve_shadow_count = obj->shadow_count;
|
2013-04-08 19:58:32 +00:00
|
|
|
VM_OBJECT_RUNLOCK(obj);
|
2008-12-02 06:50:26 +00:00
|
|
|
if (vp != NULL) {
|
|
|
|
vn_fullpath(curthread, vp, &fullpath,
|
|
|
|
&freepath);
|
2011-05-12 10:11:39 +00:00
|
|
|
kve->kve_vn_type = vntype_to_kinfo(vp->v_type);
|
2008-12-02 06:50:26 +00:00
|
|
|
cred = curthread->td_ucred;
|
|
|
|
vn_lock(vp, LK_SHARED | LK_RETRY);
|
|
|
|
if (VOP_GETATTR(vp, &va, cred) == 0) {
|
2011-05-12 10:11:39 +00:00
|
|
|
kve->kve_vn_fileid = va.va_fileid;
|
|
|
|
kve->kve_vn_fsid = va.va_fsid;
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
kve->kve_vn_fsid_freebsd11 =
|
|
|
|
kve->kve_vn_fsid; /* truncate */
|
2011-05-12 10:11:39 +00:00
|
|
|
kve->kve_vn_mode =
|
|
|
|
MAKEIMODE(va.va_type, va.va_mode);
|
|
|
|
kve->kve_vn_size = va.va_size;
|
|
|
|
kve->kve_vn_rdev = va.va_rdev;
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
kve->kve_vn_rdev_freebsd11 =
|
|
|
|
kve->kve_vn_rdev; /* truncate */
|
2011-05-12 10:11:39 +00:00
|
|
|
kve->kve_status = KF_ATTR_VALID;
|
2008-12-02 06:50:26 +00:00
|
|
|
}
|
|
|
|
vput(vp);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
kve->kve_type = KVME_TYPE_NONE;
|
|
|
|
kve->kve_ref_count = 0;
|
|
|
|
kve->kve_shadow_count = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
strlcpy(kve->kve_path, fullpath, sizeof(kve->kve_path));
|
|
|
|
if (freepath != NULL)
|
|
|
|
free(freepath, M_TEMP);
|
|
|
|
|
|
|
|
/* Pack record size down */
|
Fix core corruption caused by race in note_procstat_vmmap
This fix is spiritually similar to r287442 and was discovered thanks to
the KASSERT added in that revision.
NT_PROCSTAT_VMMAP output length, when packing kinfo structs, is tied to
the length of filenames corresponding to vnodes in the process' vm map
via vn_fullpath. As vnodes may move during coredump, this is racy.
We do not remove the race, only prevent it from causing coredump
corruption.
- Add a sysctl, kern.coredump_pack_vmmapinfo, to allow users to disable
kinfo packing for PROCSTAT_VMMAP notes. This avoids VMMAP corruption
and truncation, even if names change, at the cost of up to PATH_MAX
bytes per mapped object. The new sysctl is documented in core.5.
- Fix note_procstat_vmmap to self-limit in the second pass. This
addresses corruption, at the cost of sometimes producing a truncated
result.
- Fix PROCSTAT_VMMAP consumers libutil (and libprocstat, via copy-paste)
to grok the new zero padding.
Reported by: pho (https://people.freebsd.org/~pho/stress/log/datamove4-2.txt)
Relnotes: yes
Sponsored by: EMC / Isilon Storage Division
Differential Revision: https://reviews.freebsd.org/D3824
2015-10-06 18:07:00 +00:00
|
|
|
if ((flags & KERN_VMMAP_PACK_KINFO) != 0)
|
|
|
|
kve->kve_structsize =
|
|
|
|
offsetof(struct kinfo_vmentry, kve_path) +
|
|
|
|
strlen(kve->kve_path) + 1;
|
|
|
|
else
|
|
|
|
kve->kve_structsize = sizeof(*kve);
|
2008-12-02 06:50:26 +00:00
|
|
|
kve->kve_structsize = roundup(kve->kve_structsize,
|
|
|
|
sizeof(uint64_t));
|
Fix core corruption caused by race in note_procstat_vmmap
This fix is spiritually similar to r287442 and was discovered thanks to
the KASSERT added in that revision.
NT_PROCSTAT_VMMAP output length, when packing kinfo structs, is tied to
the length of filenames corresponding to vnodes in the process' vm map
via vn_fullpath. As vnodes may move during coredump, this is racy.
We do not remove the race, only prevent it from causing coredump
corruption.
- Add a sysctl, kern.coredump_pack_vmmapinfo, to allow users to disable
kinfo packing for PROCSTAT_VMMAP notes. This avoids VMMAP corruption
and truncation, even if names change, at the cost of up to PATH_MAX
bytes per mapped object. The new sysctl is documented in core.5.
- Fix note_procstat_vmmap to self-limit in the second pass. This
addresses corruption, at the cost of sometimes producing a truncated
result.
- Fix PROCSTAT_VMMAP consumers libutil (and libprocstat, via copy-paste)
to grok the new zero padding.
Reported by: pho (https://people.freebsd.org/~pho/stress/log/datamove4-2.txt)
Relnotes: yes
Sponsored by: EMC / Isilon Storage Division
Differential Revision: https://reviews.freebsd.org/D3824
2015-10-06 18:07:00 +00:00
|
|
|
|
|
|
|
/* Halt filling and truncate rather than exceeding maxlen */
|
|
|
|
if (maxlen != -1 && maxlen < kve->kve_structsize) {
|
|
|
|
error = 0;
|
|
|
|
vm_map_lock_read(map);
|
|
|
|
break;
|
|
|
|
} else if (maxlen != -1)
|
|
|
|
maxlen -= kve->kve_structsize;
|
|
|
|
|
2014-10-05 17:35:59 +00:00
|
|
|
if (sbuf_bcat(sb, kve, kve->kve_structsize) != 0)
|
|
|
|
error = ENOMEM;
|
2008-12-02 06:50:26 +00:00
|
|
|
vm_map_lock_read(map);
|
2014-10-05 17:35:59 +00:00
|
|
|
if (error != 0)
|
2008-12-02 06:50:26 +00:00
|
|
|
break;
|
2008-12-29 12:45:11 +00:00
|
|
|
if (last_timestamp != map->timestamp) {
|
2008-12-02 06:50:26 +00:00
|
|
|
vm_map_lookup_entry(map, addr - 1, &tmp_entry);
|
|
|
|
entry = tmp_entry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
vm_map_unlock_read(map);
|
2008-12-12 12:12:36 +00:00
|
|
|
vmspace_free(vm);
|
2008-12-02 06:50:26 +00:00
|
|
|
PRELE(p);
|
|
|
|
free(kve, M_TEMP);
|
|
|
|
return (error);
|
|
|
|
}
|
2003-07-12 02:00:16 +00:00
|
|
|
|
2013-04-14 20:01:36 +00:00
|
|
|
static int
|
|
|
|
sysctl_kern_proc_vmmap(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
struct sbuf sb;
|
|
|
|
int error, error2, *name;
|
|
|
|
|
|
|
|
name = (int *)arg1;
|
|
|
|
sbuf_new_for_sysctl(&sb, NULL, sizeof(struct kinfo_vmentry), req);
|
2015-03-14 17:08:28 +00:00
|
|
|
sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
|
2013-04-14 20:01:36 +00:00
|
|
|
error = pget((pid_t)name[0], PGET_CANDEBUG | PGET_NOTWEXIT, &p);
|
|
|
|
if (error != 0) {
|
|
|
|
sbuf_delete(&sb);
|
|
|
|
return (error);
|
|
|
|
}
|
Fix core corruption caused by race in note_procstat_vmmap
This fix is spiritually similar to r287442 and was discovered thanks to
the KASSERT added in that revision.
NT_PROCSTAT_VMMAP output length, when packing kinfo structs, is tied to
the length of filenames corresponding to vnodes in the process' vm map
via vn_fullpath. As vnodes may move during coredump, this is racy.
We do not remove the race, only prevent it from causing coredump
corruption.
- Add a sysctl, kern.coredump_pack_vmmapinfo, to allow users to disable
kinfo packing for PROCSTAT_VMMAP notes. This avoids VMMAP corruption
and truncation, even if names change, at the cost of up to PATH_MAX
bytes per mapped object. The new sysctl is documented in core.5.
- Fix note_procstat_vmmap to self-limit in the second pass. This
addresses corruption, at the cost of sometimes producing a truncated
result.
- Fix PROCSTAT_VMMAP consumers libutil (and libprocstat, via copy-paste)
to grok the new zero padding.
Reported by: pho (https://people.freebsd.org/~pho/stress/log/datamove4-2.txt)
Relnotes: yes
Sponsored by: EMC / Isilon Storage Division
Differential Revision: https://reviews.freebsd.org/D3824
2015-10-06 18:07:00 +00:00
|
|
|
error = kern_proc_vmmap_out(p, &sb, -1, KERN_VMMAP_PACK_KINFO);
|
2013-04-14 20:01:36 +00:00
|
|
|
error2 = sbuf_finish(&sb);
|
|
|
|
sbuf_delete(&sb);
|
|
|
|
return (error != 0 ? error : error2);
|
|
|
|
}
|
|
|
|
|
2007-12-02 21:52:18 +00:00
|
|
|
#if defined(STACK) || defined(DDB)
|
|
|
|
static int
|
|
|
|
sysctl_kern_proc_kstack(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
struct kinfo_kstack *kkstp;
|
|
|
|
int error, i, *name, numthreads;
|
|
|
|
lwpid_t *lwpidarray;
|
|
|
|
struct thread *td;
|
|
|
|
struct stack *st;
|
|
|
|
struct sbuf sb;
|
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
name = (int *)arg1;
|
2011-12-17 16:59:22 +00:00
|
|
|
error = pget((pid_t)name[0], PGET_NOTINEXEC | PGET_WANTREAD, &p);
|
|
|
|
if (error != 0)
|
2007-12-02 21:52:18 +00:00
|
|
|
return (error);
|
|
|
|
|
|
|
|
kkstp = malloc(sizeof(*kkstp), M_TEMP, M_WAITOK);
|
2017-10-06 21:52:28 +00:00
|
|
|
st = stack_create(M_WAITOK);
|
2007-12-02 21:52:18 +00:00
|
|
|
|
|
|
|
lwpidarray = NULL;
|
2008-03-19 06:19:01 +00:00
|
|
|
PROC_LOCK(p);
|
2016-04-17 23:22:32 +00:00
|
|
|
do {
|
2007-12-02 21:52:18 +00:00
|
|
|
if (lwpidarray != NULL) {
|
|
|
|
free(lwpidarray, M_TEMP);
|
|
|
|
lwpidarray = NULL;
|
|
|
|
}
|
|
|
|
numthreads = p->p_numthreads;
|
2008-03-19 06:19:01 +00:00
|
|
|
PROC_UNLOCK(p);
|
2007-12-02 21:52:18 +00:00
|
|
|
lwpidarray = malloc(sizeof(*lwpidarray) * numthreads, M_TEMP,
|
|
|
|
M_WAITOK | M_ZERO);
|
2008-03-19 06:19:01 +00:00
|
|
|
PROC_LOCK(p);
|
2016-04-17 23:22:32 +00:00
|
|
|
} while (numthreads < p->p_numthreads);
|
2007-12-02 21:52:18 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* XXXRW: During the below loop, execve(2) and countless other sorts
|
|
|
|
* of changes could have taken place. Should we check to see if the
|
|
|
|
* vmspace has been replaced, or the like, in order to prevent
|
|
|
|
* giving a snapshot that spans, say, execve(2), with some threads
|
|
|
|
* before and some after? Among other things, the credentials could
|
|
|
|
* have changed, in which case the right to extract debug info might
|
|
|
|
* no longer be assured.
|
|
|
|
*/
|
2016-04-17 23:22:32 +00:00
|
|
|
i = 0;
|
2007-12-02 21:52:18 +00:00
|
|
|
FOREACH_THREAD_IN_PROC(p, td) {
|
|
|
|
KASSERT(i < numthreads,
|
|
|
|
("sysctl_kern_proc_kstack: numthreads"));
|
|
|
|
lwpidarray[i] = td->td_tid;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
numthreads = i;
|
|
|
|
for (i = 0; i < numthreads; i++) {
|
|
|
|
td = thread_find(p, lwpidarray[i]);
|
|
|
|
if (td == NULL) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
bzero(kkstp, sizeof(*kkstp));
|
|
|
|
(void)sbuf_new(&sb, kkstp->kkst_trace,
|
|
|
|
sizeof(kkstp->kkst_trace), SBUF_FIXEDLEN);
|
|
|
|
thread_lock(td);
|
|
|
|
kkstp->kkst_tid = td->td_tid;
|
2015-09-11 03:54:37 +00:00
|
|
|
if (TD_IS_SWAPPED(td)) {
|
2007-12-02 21:52:18 +00:00
|
|
|
kkstp->kkst_state = KKST_STATE_SWAPPED;
|
2015-09-11 03:54:37 +00:00
|
|
|
} else if (TD_IS_RUNNING(td)) {
|
|
|
|
if (stack_save_td_running(st, td) == 0)
|
|
|
|
kkstp->kkst_state = KKST_STATE_STACKOK;
|
|
|
|
else
|
|
|
|
kkstp->kkst_state = KKST_STATE_RUNNING;
|
|
|
|
} else {
|
2007-12-02 21:52:18 +00:00
|
|
|
kkstp->kkst_state = KKST_STATE_STACKOK;
|
|
|
|
stack_save_td(st, td);
|
|
|
|
}
|
|
|
|
thread_unlock(td);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
stack_sbuf_print(&sb, st);
|
|
|
|
sbuf_finish(&sb);
|
|
|
|
sbuf_delete(&sb);
|
|
|
|
error = SYSCTL_OUT(req, kkstp, sizeof(*kkstp));
|
|
|
|
PROC_LOCK(p);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
_PRELE(p);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
if (lwpidarray != NULL)
|
|
|
|
free(lwpidarray, M_TEMP);
|
|
|
|
stack_destroy(st);
|
|
|
|
free(kkstp, M_TEMP);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-07-24 19:12:19 +00:00
|
|
|
/*
|
|
|
|
* This sysctl allows a process to retrieve the full list of groups from
|
|
|
|
* itself or another process.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
sysctl_kern_proc_groups(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
pid_t *pidp = (pid_t *)arg1;
|
|
|
|
unsigned int arglen = arg2;
|
|
|
|
struct proc *p;
|
|
|
|
struct ucred *cred;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (arglen != 1)
|
|
|
|
return (EINVAL);
|
|
|
|
if (*pidp == -1) { /* -1 means this process */
|
|
|
|
p = req->td->td_proc;
|
2014-09-04 01:21:33 +00:00
|
|
|
PROC_LOCK(p);
|
2009-07-24 19:12:19 +00:00
|
|
|
} else {
|
2011-12-17 16:59:22 +00:00
|
|
|
error = pget(*pidp, PGET_CANSEE, &p);
|
|
|
|
if (error != 0)
|
2009-07-24 19:12:19 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
cred = crhold(p->p_ucred);
|
2014-09-04 01:21:33 +00:00
|
|
|
PROC_UNLOCK(p);
|
2009-07-24 19:12:19 +00:00
|
|
|
|
|
|
|
error = SYSCTL_OUT(req, cred->cr_groups,
|
|
|
|
cred->cr_ngroups * sizeof(gid_t));
|
|
|
|
crfree(cred);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2011-11-24 20:43:37 +00:00
|
|
|
/*
|
2012-01-22 20:25:00 +00:00
|
|
|
* This sysctl allows a process to retrieve or/and set the resource limit for
|
2011-11-24 20:43:37 +00:00
|
|
|
* another process.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
sysctl_kern_proc_rlimit(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
2011-12-17 22:18:26 +00:00
|
|
|
int *name = (int *)arg1;
|
2011-11-24 20:43:37 +00:00
|
|
|
u_int namelen = arg2;
|
2012-01-22 20:25:00 +00:00
|
|
|
struct rlimit rlim;
|
2011-11-24 20:43:37 +00:00
|
|
|
struct proc *p;
|
2012-01-22 20:25:00 +00:00
|
|
|
u_int which;
|
|
|
|
int flags, error;
|
2011-11-24 20:43:37 +00:00
|
|
|
|
2012-01-22 20:25:00 +00:00
|
|
|
if (namelen != 2)
|
2011-11-24 20:43:37 +00:00
|
|
|
return (EINVAL);
|
|
|
|
|
2012-01-22 20:25:00 +00:00
|
|
|
which = (u_int)name[1];
|
|
|
|
if (which >= RLIM_NLIMITS)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
if (req->newptr != NULL && req->newlen != sizeof(rlim))
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
flags = PGET_HOLD | PGET_NOTWEXIT;
|
|
|
|
if (req->newptr != NULL)
|
|
|
|
flags |= PGET_CANDEBUG;
|
|
|
|
else
|
|
|
|
flags |= PGET_CANSEE;
|
|
|
|
error = pget((pid_t)name[0], flags, &p);
|
2011-12-17 16:59:22 +00:00
|
|
|
if (error != 0)
|
2011-11-24 20:43:37 +00:00
|
|
|
return (error);
|
2012-01-22 20:25:00 +00:00
|
|
|
|
2011-11-24 20:43:37 +00:00
|
|
|
/*
|
2012-01-22 20:25:00 +00:00
|
|
|
* Retrieve limit.
|
2011-11-24 20:43:37 +00:00
|
|
|
*/
|
2012-01-22 20:25:00 +00:00
|
|
|
if (req->oldptr != NULL) {
|
|
|
|
PROC_LOCK(p);
|
2015-06-10 10:48:12 +00:00
|
|
|
lim_rlimit_proc(p, which, &rlim);
|
2011-11-24 20:43:37 +00:00
|
|
|
PROC_UNLOCK(p);
|
|
|
|
}
|
2012-01-22 20:25:00 +00:00
|
|
|
error = SYSCTL_OUT(req, &rlim, sizeof(rlim));
|
|
|
|
if (error != 0)
|
|
|
|
goto errout;
|
2011-11-24 20:43:37 +00:00
|
|
|
|
2012-01-22 20:25:00 +00:00
|
|
|
/*
|
|
|
|
* Set limit.
|
|
|
|
*/
|
|
|
|
if (req->newptr != NULL) {
|
|
|
|
error = SYSCTL_IN(req, &rlim, sizeof(rlim));
|
|
|
|
if (error == 0)
|
|
|
|
error = kern_proc_setrlimit(curthread, p, which, &rlim);
|
|
|
|
}
|
|
|
|
|
|
|
|
errout:
|
|
|
|
PRELE(p);
|
2011-11-24 20:43:37 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2011-11-27 17:05:26 +00:00
|
|
|
/*
|
|
|
|
* This sysctl allows a process to retrieve ps_strings structure location of
|
|
|
|
* another process.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
sysctl_kern_proc_ps_strings(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
2011-12-17 22:18:26 +00:00
|
|
|
int *name = (int *)arg1;
|
2011-11-27 17:05:26 +00:00
|
|
|
u_int namelen = arg2;
|
|
|
|
struct proc *p;
|
|
|
|
vm_offset_t ps_strings;
|
|
|
|
int error;
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
uint32_t ps_strings32;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (namelen != 1)
|
|
|
|
return (EINVAL);
|
|
|
|
|
2011-12-17 16:59:22 +00:00
|
|
|
error = pget((pid_t)name[0], PGET_CANDEBUG, &p);
|
|
|
|
if (error != 0)
|
2011-11-27 17:05:26 +00:00
|
|
|
return (error);
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
if ((req->flags & SCTL_MASK32) != 0) {
|
|
|
|
/*
|
|
|
|
* We return 0 if the 32 bit emulation request is for a 64 bit
|
|
|
|
* process.
|
|
|
|
*/
|
|
|
|
ps_strings32 = SV_PROC_FLAG(p, SV_ILP32) != 0 ?
|
|
|
|
PTROUT(p->p_sysent->sv_psstrings) : 0;
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
error = SYSCTL_OUT(req, &ps_strings32, sizeof(ps_strings32));
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
ps_strings = p->p_sysent->sv_psstrings;
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
error = SYSCTL_OUT(req, &ps_strings, sizeof(ps_strings));
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2012-02-26 14:25:48 +00:00
|
|
|
/*
|
2012-03-03 11:53:35 +00:00
|
|
|
* This sysctl allows a process to retrieve umask of another process.
|
2012-02-26 14:25:48 +00:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
sysctl_kern_proc_umask(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int *name = (int *)arg1;
|
|
|
|
u_int namelen = arg2;
|
|
|
|
struct proc *p;
|
|
|
|
int error;
|
|
|
|
u_short fd_cmask;
|
2017-11-07 15:13:32 +00:00
|
|
|
pid_t pid;
|
2012-02-26 14:25:48 +00:00
|
|
|
|
|
|
|
if (namelen != 1)
|
|
|
|
return (EINVAL);
|
|
|
|
|
2017-11-07 15:13:32 +00:00
|
|
|
pid = (pid_t)name[0];
|
|
|
|
p = curproc;
|
|
|
|
if (pid == p->p_pid || pid == 0) {
|
|
|
|
fd_cmask = p->p_fd->fd_cmask;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = pget(pid, PGET_WANTREAD, &p);
|
2012-02-26 14:25:48 +00:00
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
fd_cmask = p->p_fd->fd_cmask;
|
|
|
|
PRELE(p);
|
2017-11-07 15:13:32 +00:00
|
|
|
out:
|
2012-03-03 11:53:35 +00:00
|
|
|
error = SYSCTL_OUT(req, &fd_cmask, sizeof(fd_cmask));
|
2012-02-26 14:25:48 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2012-03-23 20:05:41 +00:00
|
|
|
/*
|
|
|
|
* This sysctl allows a process to set and retrieve binary osreldate of
|
|
|
|
* another process.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
sysctl_kern_proc_osrel(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int *name = (int *)arg1;
|
|
|
|
u_int namelen = arg2;
|
|
|
|
struct proc *p;
|
|
|
|
int flags, error, osrel;
|
|
|
|
|
|
|
|
if (namelen != 1)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
if (req->newptr != NULL && req->newlen != sizeof(osrel))
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
flags = PGET_HOLD | PGET_NOTWEXIT;
|
|
|
|
if (req->newptr != NULL)
|
|
|
|
flags |= PGET_CANDEBUG;
|
|
|
|
else
|
|
|
|
flags |= PGET_CANSEE;
|
|
|
|
error = pget((pid_t)name[0], flags, &p);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
error = SYSCTL_OUT(req, &p->p_osrel, sizeof(p->p_osrel));
|
|
|
|
if (error != 0)
|
|
|
|
goto errout;
|
|
|
|
|
|
|
|
if (req->newptr != NULL) {
|
|
|
|
error = SYSCTL_IN(req, &osrel, sizeof(osrel));
|
|
|
|
if (error != 0)
|
|
|
|
goto errout;
|
|
|
|
if (osrel < 0) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
p->p_osrel = osrel;
|
|
|
|
}
|
|
|
|
errout:
|
|
|
|
PRELE(p);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2013-11-26 19:47:09 +00:00
|
|
|
static int
|
|
|
|
sysctl_kern_proc_sigtramp(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int *name = (int *)arg1;
|
|
|
|
u_int namelen = arg2;
|
|
|
|
struct proc *p;
|
|
|
|
struct kinfo_sigtramp kst;
|
|
|
|
const struct sysentvec *sv;
|
|
|
|
int error;
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
struct kinfo_sigtramp32 kst32;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (namelen != 1)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
error = pget((pid_t)name[0], PGET_CANDEBUG, &p);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
sv = p->p_sysent;
|
|
|
|
#ifdef COMPAT_FREEBSD32
|
|
|
|
if ((req->flags & SCTL_MASK32) != 0) {
|
|
|
|
bzero(&kst32, sizeof(kst32));
|
|
|
|
if (SV_PROC_FLAG(p, SV_ILP32)) {
|
|
|
|
if (sv->sv_sigcode_base != 0) {
|
|
|
|
kst32.ksigtramp_start = sv->sv_sigcode_base;
|
|
|
|
kst32.ksigtramp_end = sv->sv_sigcode_base +
|
|
|
|
*sv->sv_szsigcode;
|
|
|
|
} else {
|
|
|
|
kst32.ksigtramp_start = sv->sv_psstrings -
|
|
|
|
*sv->sv_szsigcode;
|
|
|
|
kst32.ksigtramp_end = sv->sv_psstrings;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
error = SYSCTL_OUT(req, &kst32, sizeof(kst32));
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
bzero(&kst, sizeof(kst));
|
|
|
|
if (sv->sv_sigcode_base != 0) {
|
|
|
|
kst.ksigtramp_start = (char *)sv->sv_sigcode_base;
|
|
|
|
kst.ksigtramp_end = (char *)sv->sv_sigcode_base +
|
|
|
|
*sv->sv_szsigcode;
|
|
|
|
} else {
|
|
|
|
kst.ksigtramp_start = (char *)sv->sv_psstrings -
|
|
|
|
*sv->sv_szsigcode;
|
|
|
|
kst.ksigtramp_end = (char *)sv->sv_psstrings;
|
|
|
|
}
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
error = SYSCTL_OUT(req, &kst, sizeof(kst));
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD, 0, "Process table");
|
1996-06-06 17:19:21 +00:00
|
|
|
|
2009-01-23 22:46:45 +00:00
|
|
|
SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT|
|
|
|
|
CTLFLAG_MPSAFE, 0, 0, sysctl_kern_proc, "S,proc",
|
|
|
|
"Return entire process table");
|
1996-06-06 17:19:21 +00:00
|
|
|
|
2009-01-23 22:46:45 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_GID, gid, CTLFLAG_RD | CTLFLAG_MPSAFE,
|
2004-06-19 14:03:00 +00:00
|
|
|
sysctl_kern_proc, "Process table");
|
|
|
|
|
2009-01-23 22:46:45 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_PGRP, pgrp, CTLFLAG_RD | CTLFLAG_MPSAFE,
|
1996-06-06 17:19:21 +00:00
|
|
|
sysctl_kern_proc, "Process table");
|
|
|
|
|
2009-01-23 22:46:45 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_RGID, rgid, CTLFLAG_RD | CTLFLAG_MPSAFE,
|
2004-05-22 23:11:44 +00:00
|
|
|
sysctl_kern_proc, "Process table");
|
|
|
|
|
2009-01-23 22:46:45 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_SESSION, sid, CTLFLAG_RD |
|
|
|
|
CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
|
2004-05-22 23:11:44 +00:00
|
|
|
|
2011-12-17 22:18:26 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_TTY, tty, CTLFLAG_RD | CTLFLAG_MPSAFE,
|
1996-06-06 17:19:21 +00:00
|
|
|
sysctl_kern_proc, "Process table");
|
|
|
|
|
2011-12-17 22:18:26 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_UID, uid, CTLFLAG_RD | CTLFLAG_MPSAFE,
|
1996-06-06 17:19:21 +00:00
|
|
|
sysctl_kern_proc, "Process table");
|
|
|
|
|
2009-01-23 22:46:45 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_RUID, ruid, CTLFLAG_RD | CTLFLAG_MPSAFE,
|
1996-06-06 17:19:21 +00:00
|
|
|
sysctl_kern_proc, "Process table");
|
|
|
|
|
2009-01-23 22:46:45 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_PID, pid, CTLFLAG_RD | CTLFLAG_MPSAFE,
|
1995-11-14 09:16:27 +00:00
|
|
|
sysctl_kern_proc, "Process table");
|
1999-11-16 20:31:58 +00:00
|
|
|
|
2009-01-23 22:46:45 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_PROC, proc, CTLFLAG_RD | CTLFLAG_MPSAFE,
|
2003-06-12 16:41:50 +00:00
|
|
|
sysctl_kern_proc, "Return process table, no threads");
|
|
|
|
|
2005-02-10 12:15:49 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_ARGS, args,
|
2015-04-27 11:18:16 +00:00
|
|
|
CTLFLAG_RW | CTLFLAG_CAPWR | CTLFLAG_ANYBODY | CTLFLAG_MPSAFE,
|
2000-02-08 19:54:15 +00:00
|
|
|
sysctl_kern_proc_args, "Process argument list");
|
2003-07-12 02:00:16 +00:00
|
|
|
|
2012-01-25 20:15:58 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_ENV, env, CTLFLAG_RD | CTLFLAG_MPSAFE,
|
2011-11-22 20:40:18 +00:00
|
|
|
sysctl_kern_proc_env, "Process environment");
|
|
|
|
|
2012-01-25 20:15:58 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_AUXV, auxv, CTLFLAG_RD |
|
|
|
|
CTLFLAG_MPSAFE, sysctl_kern_proc_auxv, "Process ELF auxiliary vector");
|
2011-11-22 20:40:18 +00:00
|
|
|
|
2009-01-23 22:46:45 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_PATHNAME, pathname, CTLFLAG_RD |
|
|
|
|
CTLFLAG_MPSAFE, sysctl_kern_proc_pathname, "Process executable path");
|
2005-04-18 02:10:37 +00:00
|
|
|
|
2009-01-23 22:46:45 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_SV_NAME, sv_name, CTLFLAG_RD |
|
|
|
|
CTLFLAG_MPSAFE, sysctl_kern_proc_sv_name,
|
|
|
|
"Process syscall vector name (ABI type)");
|
2004-02-22 17:54:32 +00:00
|
|
|
|
2005-02-10 12:15:49 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, (KERN_PROC_GID | KERN_PROC_INC_THREAD), gid_td,
|
2009-01-23 22:46:45 +00:00
|
|
|
CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
|
2004-06-19 14:03:00 +00:00
|
|
|
|
2005-02-10 12:15:49 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, (KERN_PROC_PGRP | KERN_PROC_INC_THREAD), pgrp_td,
|
2009-01-23 22:46:45 +00:00
|
|
|
CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
|
2004-02-22 17:54:32 +00:00
|
|
|
|
2005-02-10 12:15:49 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, (KERN_PROC_RGID | KERN_PROC_INC_THREAD), rgid_td,
|
2009-01-23 22:46:45 +00:00
|
|
|
CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
|
2004-05-22 23:11:44 +00:00
|
|
|
|
2005-02-10 12:15:49 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, (KERN_PROC_SESSION | KERN_PROC_INC_THREAD),
|
2009-01-23 22:46:45 +00:00
|
|
|
sid_td, CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
|
2004-05-22 23:11:44 +00:00
|
|
|
|
2005-02-10 12:15:49 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, (KERN_PROC_TTY | KERN_PROC_INC_THREAD), tty_td,
|
2009-01-23 22:46:45 +00:00
|
|
|
CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
|
2004-02-22 17:54:32 +00:00
|
|
|
|
2005-02-10 12:15:49 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, (KERN_PROC_UID | KERN_PROC_INC_THREAD), uid_td,
|
2009-01-23 22:46:45 +00:00
|
|
|
CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
|
2004-02-22 17:54:32 +00:00
|
|
|
|
2005-02-10 12:15:49 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, (KERN_PROC_RUID | KERN_PROC_INC_THREAD), ruid_td,
|
2009-01-23 22:46:45 +00:00
|
|
|
CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
|
2004-02-22 17:54:32 +00:00
|
|
|
|
2005-02-10 12:15:49 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, (KERN_PROC_PID | KERN_PROC_INC_THREAD), pid_td,
|
2009-01-23 22:46:45 +00:00
|
|
|
CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
|
2004-02-22 17:54:32 +00:00
|
|
|
|
2005-02-10 12:15:49 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, (KERN_PROC_PROC | KERN_PROC_INC_THREAD), proc_td,
|
2009-01-23 22:46:45 +00:00
|
|
|
CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc,
|
|
|
|
"Return process table, no threads");
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
|
2008-12-02 06:50:26 +00:00
|
|
|
#ifdef COMPAT_FREEBSD7
|
2009-01-23 22:46:45 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_OVMMAP, ovmmap, CTLFLAG_RD |
|
|
|
|
CTLFLAG_MPSAFE, sysctl_kern_proc_ovmmap, "Old Process vm map entries");
|
2008-12-02 06:50:26 +00:00
|
|
|
#endif
|
|
|
|
|
2009-01-23 22:46:45 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_VMMAP, vmmap, CTLFLAG_RD |
|
|
|
|
CTLFLAG_MPSAFE, sysctl_kern_proc_vmmap, "Process vm map entries");
|
2007-12-02 21:52:18 +00:00
|
|
|
|
|
|
|
#if defined(STACK) || defined(DDB)
|
2009-01-23 22:46:45 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_KSTACK, kstack, CTLFLAG_RD |
|
|
|
|
CTLFLAG_MPSAFE, sysctl_kern_proc_kstack, "Process kernel stacks");
|
2007-12-02 21:52:18 +00:00
|
|
|
#endif
|
2009-07-24 19:12:19 +00:00
|
|
|
|
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_GROUPS, groups, CTLFLAG_RD |
|
|
|
|
CTLFLAG_MPSAFE, sysctl_kern_proc_groups, "Process groups");
|
2011-11-24 20:43:37 +00:00
|
|
|
|
2012-01-22 20:25:00 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_RLIMIT, rlimit, CTLFLAG_RW |
|
|
|
|
CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, sysctl_kern_proc_rlimit,
|
|
|
|
"Process resource limits");
|
2011-11-27 17:05:26 +00:00
|
|
|
|
2012-01-25 20:15:58 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_PS_STRINGS, ps_strings, CTLFLAG_RD |
|
|
|
|
CTLFLAG_MPSAFE, sysctl_kern_proc_ps_strings,
|
|
|
|
"Process ps_strings location");
|
2012-02-26 14:25:48 +00:00
|
|
|
|
2012-03-03 11:53:35 +00:00
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_UMASK, umask, CTLFLAG_RD |
|
|
|
|
CTLFLAG_MPSAFE, sysctl_kern_proc_umask, "Process umask");
|
2012-03-23 20:05:41 +00:00
|
|
|
|
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_OSREL, osrel, CTLFLAG_RW |
|
|
|
|
CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, sysctl_kern_proc_osrel,
|
|
|
|
"Process binary osreldate");
|
2013-11-26 19:47:09 +00:00
|
|
|
|
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_SIGTRAMP, sigtramp, CTLFLAG_RD |
|
|
|
|
CTLFLAG_MPSAFE, sysctl_kern_proc_sigtramp,
|
|
|
|
"Process signal trampoline location");
|
2014-12-13 16:18:29 +00:00
|
|
|
|
|
|
|
int allproc_gen;
|
|
|
|
|
2016-02-08 10:54:27 +00:00
|
|
|
/*
|
|
|
|
* stop_all_proc() purpose is to stop all process which have usermode,
|
|
|
|
* except current process for obvious reasons. This makes it somewhat
|
|
|
|
* unreliable when invoked from multithreaded process. The service
|
|
|
|
* must not be user-callable anyway.
|
|
|
|
*/
|
2014-12-13 16:18:29 +00:00
|
|
|
void
|
|
|
|
stop_all_proc(void)
|
|
|
|
{
|
|
|
|
struct proc *cp, *p;
|
|
|
|
int r, gen;
|
|
|
|
bool restart, seen_stopped, seen_exiting, stopped_some;
|
|
|
|
|
|
|
|
cp = curproc;
|
|
|
|
allproc_loop:
|
|
|
|
sx_xlock(&allproc_lock);
|
|
|
|
gen = allproc_gen;
|
|
|
|
seen_exiting = seen_stopped = stopped_some = restart = false;
|
|
|
|
LIST_REMOVE(cp, p_list);
|
|
|
|
LIST_INSERT_HEAD(&allproc, cp, p_list);
|
|
|
|
for (;;) {
|
|
|
|
p = LIST_NEXT(cp, p_list);
|
|
|
|
if (p == NULL)
|
|
|
|
break;
|
|
|
|
LIST_REMOVE(cp, p_list);
|
|
|
|
LIST_INSERT_AFTER(p, cp, p_list);
|
|
|
|
PROC_LOCK(p);
|
2016-02-09 16:30:16 +00:00
|
|
|
if ((p->p_flag & (P_KPROC | P_SYSTEM | P_TOTAL_STOP)) != 0) {
|
2014-12-13 16:18:29 +00:00
|
|
|
PROC_UNLOCK(p);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if ((p->p_flag & P_WEXIT) != 0) {
|
|
|
|
seen_exiting = true;
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (P_SHOULDSTOP(p) == P_STOPPED_SINGLE) {
|
|
|
|
/*
|
|
|
|
* Stopped processes are tolerated when there
|
|
|
|
* are no other processes which might continue
|
|
|
|
* them. P_STOPPED_SINGLE but not
|
|
|
|
* P_TOTAL_STOP process still has at least one
|
|
|
|
* thread running.
|
|
|
|
*/
|
|
|
|
seen_stopped = true;
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
sx_xunlock(&allproc_lock);
|
2019-02-03 21:31:40 +00:00
|
|
|
_PHOLD(p);
|
2014-12-13 16:18:29 +00:00
|
|
|
r = thread_single(p, SINGLE_ALLPROC);
|
|
|
|
if (r != 0)
|
|
|
|
restart = true;
|
|
|
|
else
|
|
|
|
stopped_some = true;
|
|
|
|
_PRELE(p);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
sx_xlock(&allproc_lock);
|
|
|
|
}
|
|
|
|
/* Catch forked children we did not see in iteration. */
|
|
|
|
if (gen != allproc_gen)
|
|
|
|
restart = true;
|
|
|
|
sx_xunlock(&allproc_lock);
|
|
|
|
if (restart || stopped_some || seen_exiting || seen_stopped) {
|
|
|
|
kern_yield(PRI_USER);
|
|
|
|
goto allproc_loop;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
resume_all_proc(void)
|
|
|
|
{
|
|
|
|
struct proc *cp, *p;
|
|
|
|
|
|
|
|
cp = curproc;
|
|
|
|
sx_xlock(&allproc_lock);
|
2017-12-28 13:16:32 +00:00
|
|
|
again:
|
2014-12-13 16:18:29 +00:00
|
|
|
LIST_REMOVE(cp, p_list);
|
|
|
|
LIST_INSERT_HEAD(&allproc, cp, p_list);
|
|
|
|
for (;;) {
|
|
|
|
p = LIST_NEXT(cp, p_list);
|
|
|
|
if (p == NULL)
|
|
|
|
break;
|
|
|
|
LIST_REMOVE(cp, p_list);
|
|
|
|
LIST_INSERT_AFTER(p, cp, p_list);
|
|
|
|
PROC_LOCK(p);
|
|
|
|
if ((p->p_flag & P_TOTAL_STOP) != 0) {
|
|
|
|
sx_xunlock(&allproc_lock);
|
|
|
|
_PHOLD(p);
|
|
|
|
thread_single_end(p, SINGLE_ALLPROC);
|
|
|
|
_PRELE(p);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
sx_xlock(&allproc_lock);
|
|
|
|
} else {
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
}
|
|
|
|
}
|
2017-12-28 13:16:32 +00:00
|
|
|
/* Did the loop above missed any stopped process ? */
|
2018-06-20 11:42:06 +00:00
|
|
|
FOREACH_PROC_IN_SYSTEM(p) {
|
2017-12-28 13:16:32 +00:00
|
|
|
/* No need for proc lock. */
|
|
|
|
if ((p->p_flag & P_TOTAL_STOP) != 0)
|
|
|
|
goto again;
|
|
|
|
}
|
2014-12-13 16:18:29 +00:00
|
|
|
sx_xunlock(&allproc_lock);
|
|
|
|
}
|
|
|
|
|
2016-02-08 10:54:27 +00:00
|
|
|
/* #define TOTAL_STOP_DEBUG 1 */
|
2014-12-13 16:18:29 +00:00
|
|
|
#ifdef TOTAL_STOP_DEBUG
|
|
|
|
volatile static int ap_resume;
|
|
|
|
#include <sys/mount.h>
|
|
|
|
|
|
|
|
static int
|
|
|
|
sysctl_debug_stop_all_proc(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int error, val;
|
|
|
|
|
|
|
|
val = 0;
|
|
|
|
ap_resume = 0;
|
|
|
|
error = sysctl_handle_int(oidp, &val, 0, req);
|
|
|
|
if (error != 0 || req->newptr == NULL)
|
|
|
|
return (error);
|
|
|
|
if (val != 0) {
|
|
|
|
stop_all_proc();
|
|
|
|
syncer_suspend();
|
|
|
|
while (ap_resume == 0)
|
|
|
|
;
|
|
|
|
syncer_resume();
|
|
|
|
resume_all_proc();
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_debug, OID_AUTO, stop_all_proc, CTLTYPE_INT | CTLFLAG_RW |
|
2014-12-14 08:43:13 +00:00
|
|
|
CTLFLAG_MPSAFE, __DEVOLATILE(int *, &ap_resume), 0,
|
|
|
|
sysctl_debug_stop_all_proc, "I",
|
2014-12-13 16:18:29 +00:00
|
|
|
"");
|
|
|
|
#endif
|