e67fc5771d
In order to make it more clear that ticks should be used for timers and realtime should be used for timestamps / displaying the date/time, getuptime() was renamed to getticks() and getuptime2() was renamed to getuptime(). Servers, drivers, libraries, tests, etc that use getuptime()/getuptime2() have been updated. In instances where a realtime was calculated, the calculation was changed to use realtime. System calls clock_getres() and clock_gettime() were added to PM/libc.
537 lines
15 KiB
C
537 lines
15 KiB
C
/* ProcFS - tree.c - by Alen Stojanov and David van Moolenbroek */
|
|
|
|
#include "inc.h"
|
|
|
|
struct proc proc[NR_PROCS + NR_TASKS];
|
|
struct mproc mproc[NR_PROCS];
|
|
struct fproc fproc[NR_PROCS];
|
|
|
|
static int nr_pid_entries;
|
|
|
|
/*===========================================================================*
|
|
* slot_in_use *
|
|
*===========================================================================*/
|
|
static int slot_in_use(int slot)
|
|
{
|
|
/* Return whether the given slot is in use by a process.
|
|
*/
|
|
|
|
/* For kernel tasks, check only the kernel slot. Tasks do not have a
|
|
* PM/VFS process slot.
|
|
*/
|
|
if (slot < NR_TASKS)
|
|
return (proc[slot].p_rts_flags != RTS_SLOT_FREE);
|
|
|
|
/* For regular processes, check only the PM slot. Do not check the
|
|
* kernel slot, because that would skip zombie processes. The PID check
|
|
* should be redundant, but if it fails, procfs could crash.
|
|
*/
|
|
return ((mproc[slot - NR_TASKS].mp_flags & IN_USE) &&
|
|
mproc[slot - NR_TASKS].mp_pid != 0);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* check_owner *
|
|
*===========================================================================*/
|
|
static int check_owner(struct inode *node, int slot)
|
|
{
|
|
/* Check if the owner user and group ID of the inode are still in sync
|
|
* the current effective user and group ID of the given process.
|
|
*/
|
|
struct inode_stat stat;
|
|
|
|
if (slot < NR_TASKS) return TRUE;
|
|
|
|
get_inode_stat(node, &stat);
|
|
|
|
return (stat.uid == mproc[slot - NR_TASKS].mp_effuid &&
|
|
stat.gid == mproc[slot - NR_TASKS].mp_effgid);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* make_stat *
|
|
*===========================================================================*/
|
|
static void make_stat(struct inode_stat *stat, int slot, int index)
|
|
{
|
|
/* Fill in an inode_stat structure for the given process slot and
|
|
* per-pid file index (or NO_INDEX for the process subdirectory root).
|
|
*/
|
|
|
|
if (index == NO_INDEX)
|
|
stat->mode = DIR_ALL_MODE;
|
|
else
|
|
stat->mode = pid_files[index].mode;
|
|
|
|
if (slot < NR_TASKS) {
|
|
stat->uid = SUPER_USER;
|
|
stat->gid = SUPER_USER;
|
|
} else {
|
|
stat->uid = mproc[slot - NR_TASKS].mp_effuid;
|
|
stat->gid = mproc[slot - NR_TASKS].mp_effgid;
|
|
}
|
|
|
|
stat->size = 0;
|
|
stat->dev = NO_DEV;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* dir_is_pid *
|
|
*===========================================================================*/
|
|
static int dir_is_pid(struct inode *node)
|
|
{
|
|
/* Return whether the given node is a PID directory.
|
|
*/
|
|
|
|
return (get_parent_inode(node) == get_root_inode() &&
|
|
get_inode_index(node) != NO_INDEX);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* update_proc_table *
|
|
*===========================================================================*/
|
|
static int update_proc_table(void)
|
|
{
|
|
/* Get the process table from the kernel.
|
|
* Check the magic number in the table entries.
|
|
*/
|
|
int r, slot;
|
|
|
|
if ((r = sys_getproctab(proc)) != OK) return r;
|
|
|
|
for (slot = 0; slot < NR_PROCS + NR_TASKS; slot++) {
|
|
if (proc[slot].p_magic != PMAGIC) {
|
|
printf("PROCFS: system version mismatch!\n");
|
|
|
|
return EINVAL;
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* update_mproc_table *
|
|
*===========================================================================*/
|
|
static int update_mproc_table(void)
|
|
{
|
|
/* Get the process table from PM.
|
|
* Check the magic number in the table entries.
|
|
*/
|
|
int r, slot;
|
|
|
|
r = getsysinfo(PM_PROC_NR, SI_PROC_TAB, mproc, sizeof(mproc));
|
|
if (r != OK) return r;
|
|
|
|
for (slot = 0; slot < NR_PROCS; slot++) {
|
|
if (mproc[slot].mp_magic != MP_MAGIC) {
|
|
printf("PROCFS: PM version mismatch!\n");
|
|
|
|
return EINVAL;
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* update_fproc_table *
|
|
*===========================================================================*/
|
|
static int update_fproc_table(void)
|
|
{
|
|
/* Get the process table from VFS.
|
|
*/
|
|
|
|
return getsysinfo(VFS_PROC_NR, SI_PROC_TAB, fproc, sizeof(fproc));
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* update_tables *
|
|
*===========================================================================*/
|
|
static int update_tables(void)
|
|
{
|
|
/* Get the process tables from the kernel, PM, and VFS.
|
|
*/
|
|
int r;
|
|
|
|
if ((r = update_proc_table()) != OK) return r;
|
|
|
|
if ((r = update_mproc_table()) != OK) return r;
|
|
|
|
if ((r = update_fproc_table()) != OK) return r;
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* init_tree *
|
|
*===========================================================================*/
|
|
int init_tree(void)
|
|
{
|
|
/* Initialize this module, before VTreeFS is started. As part of the
|
|
* process, check if we're not compiled against a kernel different from
|
|
* the one that is running at the moment.
|
|
*/
|
|
int i, r;
|
|
|
|
if ((r = update_tables()) != OK)
|
|
return r;
|
|
|
|
/* Get the maximum number of entries that we may add to each PID's
|
|
* directory. We could just default to a large value, but why not get
|
|
* it right?
|
|
*/
|
|
for (i = 0; pid_files[i].name != NULL; i++);
|
|
|
|
nr_pid_entries = i;
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* out_of_inodes *
|
|
*===========================================================================*/
|
|
static void out_of_inodes(void)
|
|
{
|
|
/* Out of inodes - the NR_INODES value is set too low. We can not do
|
|
* much, but we might be able to continue with degraded functionality,
|
|
* so do not panic. If the NR_INODES value is not below the *crucial*
|
|
* minimum, the symptom of this case will be an incomplete listing of
|
|
* the main proc directory.
|
|
*/
|
|
static int warned = FALSE;
|
|
|
|
if (warned == FALSE) {
|
|
printf("PROCFS: out of inodes!\n");
|
|
|
|
warned = TRUE;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* construct_pid_dirs *
|
|
*===========================================================================*/
|
|
static void construct_pid_dirs(void)
|
|
{
|
|
/* Regenerate the set of PID directories in the root directory of the
|
|
* file system. Add new directories and delete old directories as
|
|
* appropriate; leave unchanged those that should remain the same.
|
|
*
|
|
* We have to make two passes. Otherwise, we would trigger a vtreefs
|
|
* assert when we add an entry for a PID before deleting the previous
|
|
* entry for that PID. While rare, such rapid PID reuse does occur in
|
|
* practice.
|
|
*/
|
|
struct inode *root, *node;
|
|
struct inode_stat stat;
|
|
char name[PNAME_MAX+1];
|
|
pid_t pid;
|
|
int i;
|
|
|
|
root = get_root_inode();
|
|
|
|
/* First pass: delete old entries. */
|
|
for (i = 0; i < NR_PROCS + NR_TASKS; i++) {
|
|
/* Do we already have an inode associated with this slot? */
|
|
node = get_inode_by_index(root, i);
|
|
if (node == NULL)
|
|
continue;
|
|
|
|
/* If the process slot is not in use, delete the associated
|
|
* inode.
|
|
*/
|
|
if (!slot_in_use(i)) {
|
|
delete_inode(node);
|
|
|
|
continue;
|
|
}
|
|
|
|
/* Otherwise, get the process ID. */
|
|
if (i < NR_TASKS)
|
|
pid = (pid_t) (i - NR_TASKS);
|
|
else
|
|
pid = mproc[i - NR_TASKS].mp_pid;
|
|
|
|
/* If there is an old entry, see if the pid matches the current
|
|
* entry, and the owner is still the same. Otherwise, delete
|
|
* the old entry first. We reconstruct the entire subtree even
|
|
* if only the owner changed, for security reasons: if a
|
|
* process could keep open a file or directory across the owner
|
|
* change, it might be able to access information it shouldn't.
|
|
*/
|
|
if (pid != (pid_t) get_inode_cbdata(node) ||
|
|
!check_owner(node, i))
|
|
delete_inode(node);
|
|
}
|
|
|
|
/* Second pass: add new entries. */
|
|
for (i = 0; i < NR_PROCS + NR_TASKS; i++) {
|
|
/* If the process slot is not in use, skip this slot. */
|
|
if (!slot_in_use(i))
|
|
continue;
|
|
|
|
/* If we have an inode associated with this slot, we have
|
|
* already checked it to be up-to-date above.
|
|
*/
|
|
if (get_inode_by_index(root, i) != NULL)
|
|
continue;
|
|
|
|
/* Get the process ID. */
|
|
if (i < NR_TASKS)
|
|
pid = (pid_t) (i - NR_TASKS);
|
|
else
|
|
pid = mproc[i - NR_TASKS].mp_pid;
|
|
|
|
/* Add the entry for the process slot. */
|
|
snprintf(name, PNAME_MAX + 1, "%d", pid);
|
|
|
|
make_stat(&stat, i, NO_INDEX);
|
|
|
|
node = add_inode(root, name, i, &stat, nr_pid_entries,
|
|
(cbdata_t) pid);
|
|
|
|
if (node == NULL)
|
|
out_of_inodes();
|
|
}
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* make_one_pid_entry *
|
|
*===========================================================================*/
|
|
static void make_one_pid_entry(struct inode *parent, char *name, int slot)
|
|
{
|
|
/* Construct one file in a PID directory, if a file with the given name
|
|
* should exist at all.
|
|
*/
|
|
struct inode *node;
|
|
struct inode_stat stat;
|
|
int i;
|
|
|
|
/* Don't readd if it is already there. */
|
|
node = get_inode_by_name(parent, name);
|
|
if (node != NULL)
|
|
return;
|
|
|
|
/* Only add the file if it is a known, registered name. */
|
|
for (i = 0; pid_files[i].name != NULL; i++) {
|
|
if (!strcmp(name, pid_files[i].name)) {
|
|
make_stat(&stat, slot, i);
|
|
|
|
node = add_inode(parent, name, i, &stat,
|
|
(index_t) 0, (cbdata_t) 0);
|
|
|
|
if (node == NULL)
|
|
out_of_inodes();
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* make_all_pid_entries *
|
|
*===========================================================================*/
|
|
static void make_all_pid_entries(struct inode *parent, int slot)
|
|
{
|
|
/* Construct all files in a PID directory.
|
|
*/
|
|
struct inode *node;
|
|
struct inode_stat stat;
|
|
int i;
|
|
|
|
for (i = 0; pid_files[i].name != NULL; i++) {
|
|
node = get_inode_by_index(parent, i);
|
|
if (node != NULL)
|
|
continue;
|
|
|
|
make_stat(&stat, slot, i);
|
|
|
|
node = add_inode(parent, pid_files[i].name, i, &stat,
|
|
(index_t) 0, (cbdata_t) 0);
|
|
|
|
if (node == NULL)
|
|
out_of_inodes();
|
|
}
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* construct_pid_entries *
|
|
*===========================================================================*/
|
|
static void construct_pid_entries(struct inode *parent, char *name)
|
|
{
|
|
/* Construct one requested file entry, or all file entries, in a PID
|
|
* directory.
|
|
*/
|
|
int slot;
|
|
|
|
slot = get_inode_index(parent);
|
|
assert(slot >= 0 && slot < NR_TASKS + NR_PROCS);
|
|
|
|
/* If this process is already gone, delete the directory now. */
|
|
if (!slot_in_use(slot)) {
|
|
delete_inode(parent);
|
|
|
|
return;
|
|
}
|
|
|
|
/* If a specific file name is being looked up, see if we have to add
|
|
* an inode for that file. If the directory contents are being
|
|
* retrieved, add all files that have not yet been added.
|
|
*/
|
|
if (name != NULL)
|
|
make_one_pid_entry(parent, name, slot);
|
|
else
|
|
make_all_pid_entries(parent, slot);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* pid_read *
|
|
*===========================================================================*/
|
|
static void pid_read(struct inode *node)
|
|
{
|
|
/* Data is requested from one of the files in a PID directory. Call the
|
|
* function that is responsible for generating the data for that file.
|
|
*/
|
|
struct inode *parent;
|
|
int slot, index;
|
|
|
|
/* Get the slot number of the process. Note that this currently will
|
|
* not work for files not in the top-level pid subdirectory.
|
|
*/
|
|
parent = get_parent_inode(node);
|
|
|
|
slot = get_inode_index(parent);
|
|
|
|
/* Get this file's index number. */
|
|
index = get_inode_index(node);
|
|
|
|
/* Call the handler procedure for the file. */
|
|
((void (*) (int)) pid_files[index].data)(slot);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* pid_link *
|
|
*===========================================================================*/
|
|
static int pid_link(struct inode *UNUSED(node), char *ptr, int max)
|
|
{
|
|
/* The contents of a symbolic link in a PID directory are requested.
|
|
* This function is a placeholder for future use.
|
|
*/
|
|
|
|
/* Nothing yet. */
|
|
strlcpy(ptr, "", max);
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* lookup_hook *
|
|
*===========================================================================*/
|
|
int lookup_hook(struct inode *parent, char *name,
|
|
cbdata_t UNUSED(cbdata))
|
|
{
|
|
/* Path name resolution hook, for a specific parent and name pair.
|
|
* If needed, update our own view of the system first; after that,
|
|
* determine whether we need to (re)generate certain files.
|
|
*/
|
|
static clock_t last_update = 0;
|
|
clock_t now;
|
|
int r;
|
|
|
|
/* Update lazily for lookups, as this gets too expensive otherwise.
|
|
* Alternative: pull in only PM's table?
|
|
*/
|
|
if ((r = getticks(&now)) != OK)
|
|
panic(__FILE__, "unable to get uptime", r);
|
|
|
|
if (last_update != now) {
|
|
update_tables();
|
|
|
|
last_update = now;
|
|
}
|
|
|
|
/* If the parent is the root directory, we must now reconstruct all
|
|
* entries, because some of them might have been garbage collected.
|
|
* We must update the entire tree at once; if we update individual
|
|
* entries, we risk name collisions.
|
|
*/
|
|
if (parent == get_root_inode()) {
|
|
construct_pid_dirs();
|
|
}
|
|
/* If the parent is a process directory, we may need to (re)construct
|
|
* the entry being looked up.
|
|
*/
|
|
else if (dir_is_pid(parent)) {
|
|
/* We might now have deleted our current containing directory;
|
|
* construct_pid_entries() will take care of this case.
|
|
*/
|
|
construct_pid_entries(parent, name);
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* getdents_hook *
|
|
*===========================================================================*/
|
|
int getdents_hook(struct inode *node, cbdata_t UNUSED(cbdata))
|
|
{
|
|
/* Directory entry retrieval hook, for potentially all files in a
|
|
* directory. Make sure that all files that are supposed to be
|
|
* returned, are actually part of the virtual tree.
|
|
*/
|
|
|
|
if (node == get_root_inode()) {
|
|
update_tables();
|
|
|
|
construct_pid_dirs();
|
|
} else if (dir_is_pid(node)) {
|
|
construct_pid_entries(node, NULL /*name*/);
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* read_hook *
|
|
*===========================================================================*/
|
|
int read_hook(struct inode *node, off_t off, char **ptr,
|
|
size_t *len, cbdata_t cbdata)
|
|
{
|
|
/* Regular file read hook. Call the appropriate callback function to
|
|
* generate and return the data.
|
|
*/
|
|
|
|
buf_init(off, *len);
|
|
|
|
/* Populate the buffer with the proper content. */
|
|
if (get_inode_index(node) != NO_INDEX) {
|
|
pid_read(node);
|
|
} else {
|
|
((void (*) (void)) cbdata)();
|
|
}
|
|
|
|
*len = buf_get(ptr);
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* rdlink_hook *
|
|
*===========================================================================*/
|
|
int rdlink_hook(struct inode *node, char *ptr, size_t max,
|
|
cbdata_t UNUSED(cbdata))
|
|
{
|
|
/* Symbolic link resolution hook. Not used yet.
|
|
*/
|
|
struct inode *parent;
|
|
|
|
/* Get the parent inode. */
|
|
parent = get_parent_inode(node);
|
|
|
|
/* If the parent inode is a pid directory, call the pid handler.
|
|
*/
|
|
if (parent != NULL && dir_is_pid(parent))
|
|
pid_link(node, ptr, max);
|
|
|
|
return OK;
|
|
}
|