/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2003 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * File descriptor usage * * The number of processes that can be effectively managed is limited to less * than half the number of descriptors available: one for each process's * psinfo, the other its pagedata. When managing more processes, file * descriptors are revoked as needed, in such a way as to maximize the * distribution of descriptors to pagedata which will be useful in meeting a * cap without paging out the process's working set, while retaining some * benefit from caching psinfo descriptors, and leaving enough available for * use by external consumers, such as are needed for project enumeration or * configuration file reading. * * Revokable file descriptors are opened and associated with a callback * function which can be invoked to revoke them later. pagedata and psinfo * descriptors are differentiated for the purposes of preferring pagedata over * psinfo, which effectively places the performance of rcapd behind the * importance of making good page selections. The one exception is that one * psinfo descriptor is guaranteed a place at any time, for the benefit of * psinfo updates of a presently currently-scanned process. Descriptors are * otherwise revoked in LIFO order. */ #include <sys/types.h> #include <stdlib.h> #include <errno.h> #include <fcntl.h> #include <limits.h> #include <strings.h> #include <unistd.h> #include "rcapd_rfd.h" #include "utils.h" static rfd_t *tail; /* tail of global list */ static int rfd_revoke_next(rfd_class_t); /* * Return the previous rfd_t of the given class, starting at (and including) * the given rfd_t. */ static rfd_t * rfd_find_prev_class(rfd_t *rfd, rfd_class_t class) { while (rfd != NULL && rfd->rfd_class != class) rfd = rfd->rfd_prev; return (rfd); } /* * Revoke and free the given rfd_t, returning as close does. */ static int rfd_revoke_fd(rfd_t *rfd) { if (rfd->rfd_revoke != NULL) rfd->rfd_revoke(rfd); return (rfd_close(rfd->rfd_fd)); } /* * Revoke the next file descriptor according to the above constraints. Return * nonzero if there are none to revoke. */ static int rfd_revoke_next(rfd_class_t class) { rfd_t *rfd = NULL; if (tail == NULL) { debug("nothing to revoke\n"); return (-1); } /* * RESERVED-clsas descriptors are all equivalent and may not be revoked * to satisfy another request of the same clsas. rfd_reserve() uses * this to reserve descriptors by first allocating, then closing, these * descriptors. */ if (class != RFD_RESERVED) rfd = rfd_find_prev_class(tail, RFD_RESERVED); /* * Next try psinfo descriptors, leaving at least one open. Revoke the * second-last psinfo descriptor, if possible. */ if (rfd == NULL) { rfd = rfd_find_prev_class(tail, RFD_PSINFO); if (rfd != NULL) rfd = rfd->rfd_prev_class; } /* * Otherwise, revoke the last descriptor allocated, taking the same * care as above that it is not reserved, if the reserved kind is * sought. */ if (rfd == NULL) { rfd = tail; while (rfd != NULL && class == RFD_RESERVED && rfd->rfd_class == RFD_RESERVED) rfd = rfd->rfd_prev; } if (rfd != NULL) return (rfd_revoke_fd(rfd)); /* * Nothing but reserved-class descriptors are revocable, while a * reserved- class descriptor was sought. */ return (-1); } /* * Opens a file of the given class, which can later be revoked with the given * callback. Returns as open does. The callback should reset any state that * this caller establishes after the open, but should not close the descriptor, * which will be done when the caller explicitly does so with rfd_close(), or * the descriptor is revoked with rfd_revoke(). */ int rfd_open(char *name, int revoke_ok, rfd_class_t class, void(*revoke)(struct rfd *), void *data, int oflag, mode_t mode) { int fd; rfd_t *rfd; while ((fd = open(name, oflag, mode)) == -1 && (errno == ENFILE || errno == EMFILE)) { if (revoke_ok) { if (rfd_revoke_next(class) != 0) return (-1); } else break; } if (fd != -1) { /* * Create rfd_t and link into list. */ rfd = malloc(sizeof (*rfd)); if (rfd == NULL) { (void) close(fd); return (-1); } (void) bzero(rfd, sizeof (*rfd)); rfd->rfd_fd = fd; rfd->rfd_class = class; rfd->rfd_revoke = revoke; rfd->rfd_data = data; if (tail != NULL) rfd->rfd_prev_class = rfd_find_prev_class(tail, class); else rfd->rfd_prev_class = tail; rfd->rfd_prev = tail; if (tail != NULL) tail->rfd_next = rfd; tail = rfd; } return (fd); } /* * Close a given file descriptor, and return as close() does. */ int rfd_close(int fd) { rfd_t *nextclass; rfd_t *rfdprev; rfd_t *rfd; #ifdef DEBUG int freed = 0; #endif /* DEBUG */ rfd = tail; while (rfd != NULL) { rfdprev = rfd->rfd_prev; if (rfd->rfd_fd == fd) { if (rfd->rfd_prev != NULL) rfd->rfd_prev->rfd_next = rfd->rfd_next; if (rfd->rfd_next != NULL) rfd->rfd_next->rfd_prev = rfd->rfd_prev; if (tail == rfd) tail = rfd->rfd_prev; for (nextclass = rfd->rfd_next; nextclass != NULL; nextclass = nextclass->rfd_next) if (nextclass->rfd_class == rfd->rfd_class) { nextclass->rfd_prev_class = rfd->rfd_prev_class; break; } free(rfd); #ifdef DEBUG freed = 1; #endif /* DEBUG */ break; } rfd = rfdprev; } ASSERT(freed == 1); return (close(fd)); } /* * Makes sure at least n descriptors are available. Returns nonzero if * successful. */ int rfd_reserve(int n) { int i; int fd = 0; rfd_t *otail = NULL; rfd_t *rfdnext; for (i = 0; i < n && fd >= 0; i++) { /* * rfd_open() will append as many RFD_RESERVED-clsas * descriptors to the current tail as are requested, revoking * non-RFD_RESERVED-class descriptors until nothing else can be * revoked or the reservation is met. */ fd = rfd_open("/dev/null", 1, RFD_RESERVED, NULL, NULL, O_RDONLY, 0); if (otail == NULL) otail = tail; } if (fd == -1) debug("couldn't allocate %d descriptors\n", n); while (otail != NULL) { rfdnext = otail->rfd_next; (void) rfd_close(otail->rfd_fd); otail = rfdnext; } return (fd != -1); }
