Return to quota.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc

Annotation of embedaddon/ntp/lib/isc/quota.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * Copyright (C) 2004, 2005, 2007  Internet Systems Consortium, Inc. ("ISC")
                      3:  * Copyright (C) 2000, 2001  Internet Software Consortium.
                      4:  *
                      5:  * Permission to use, copy, modify, and/or distribute this software for any
                      6:  * purpose with or without fee is hereby granted, provided that the above
                      7:  * copyright notice and this permission notice appear in all copies.
                      8:  *
                      9:  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
                     10:  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
                     11:  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
                     12:  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
                     13:  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
                     14:  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
                     15:  * PERFORMANCE OF THIS SOFTWARE.
                     16:  */
                     17: 
                     18: /* $Id: quota.c,v 1.18 2007/06/19 23:47:17 tbox Exp $ */
                     19: 
                     20: /*! \file */
                     21: 
                     22: #include <config.h>
                     23: 
                     24: #include <stddef.h>
                     25: 
                     26: #include <isc/quota.h>
                     27: #include <isc/util.h>
                     28: 
                     29: isc_result_t
                     30: isc_quota_init(isc_quota_t *quota, int max) {
                     31:        quota->max = max;
                     32:        quota->used = 0;
                     33:        quota->soft = 0;
                     34:        return (isc_mutex_init(&quota->lock));
                     35: }
                     36: 
                     37: void
                     38: isc_quota_destroy(isc_quota_t *quota) {
                     39:        INSIST(quota->used == 0);
                     40:        quota->max = 0;
                     41:        quota->used = 0;
                     42:        quota->soft = 0;
                     43:        DESTROYLOCK(&quota->lock);
                     44: }
                     45: 
                     46: void
                     47: isc_quota_soft(isc_quota_t *quota, int soft) {
                     48:        LOCK(&quota->lock);
                     49:        quota->soft = soft;
                     50:        UNLOCK(&quota->lock);
                     51: }
                     52: 
                     53: void
                     54: isc_quota_max(isc_quota_t *quota, int max) {
                     55:        LOCK(&quota->lock);
                     56:        quota->max = max;
                     57:        UNLOCK(&quota->lock);
                     58: }
                     59: 
                     60: isc_result_t
                     61: isc_quota_reserve(isc_quota_t *quota) {
                     62:        isc_result_t result;
                     63:        LOCK(&quota->lock);
                     64:        if (quota->max == 0 || quota->used < quota->max) {
                     65:                if (quota->soft == 0 || quota->used < quota->soft)
                     66:                        result = ISC_R_SUCCESS;
                     67:                else
                     68:                        result = ISC_R_SOFTQUOTA;
                     69:                quota->used++;
                     70:        } else
                     71:                result = ISC_R_QUOTA;
                     72:        UNLOCK(&quota->lock);
                     73:        return (result);
                     74: }
                     75: 
                     76: void
                     77: isc_quota_release(isc_quota_t *quota) {
                     78:        LOCK(&quota->lock);
                     79:        INSIST(quota->used > 0);
                     80:        quota->used--;
                     81:        UNLOCK(&quota->lock);
                     82: }
                     83: 
                     84: isc_result_t
                     85: isc_quota_attach(isc_quota_t *quota, isc_quota_t **p)
                     86: {
                     87:        isc_result_t result;
                     88:        INSIST(p != NULL && *p == NULL);
                     89:        result = isc_quota_reserve(quota);
                     90:        if (result == ISC_R_SUCCESS || result == ISC_R_SOFTQUOTA)
                     91:                *p = quota;
                     92:        return (result);
                     93: }
                     94: 
                     95: void
                     96: isc_quota_detach(isc_quota_t **p)
                     97: {
                     98:        INSIST(p != NULL && *p != NULL);
                     99:        isc_quota_release(*p);
                    100:        *p = NULL;
                    101: }