Changeset 0739963 in rtems


Ignore:
Timestamp:
Apr 19, 2004, 1:49:10 PM (16 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
d3fdf89f
Parents:
429ba3b
Message:

2004-04-19 Ralf Corsepius <ralf_corsepius@…>

  • libnetworking/sys/sysctl.h: Partial update from FreeBSD.
  • libnetworking/kern/kern_sysctl.c: Partial update from FreeBSD.
Location:
cpukit
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • cpukit/ChangeLog

    r429ba3b r0739963  
     12004-04-19      Ralf Corsepius <ralf_corsepius@rtems.org>
     2
     3        * libnetworking/sys/sysctl.h: Partial update from FreeBSD.
     4        * libnetworking/kern/kern_sysctl.c: Partial update from FreeBSD.
     5
    162004-04-17      Ralf Corsepius <ralf_corsepius@rtems.org>
    27
  • cpukit/libnetworking/kern/kern_sysctl.c

    r429ba3b r0739963  
    1717 *    notice, this list of conditions and the following disclaimer in the
    1818 *    documentation and/or other materials provided with the distribution.
    19  * 3. All advertising materials mentioning features or use of this software
    20  *    must display the following acknowledgement:
    21  *      This product includes software developed by the University of
    22  *      California, Berkeley and its contributors.
    2319 * 4. Neither the name of the University nor the names of its contributors
    2420 *    may be used to endorse or promote products derived from this software
     
    442438 * "Staff-functions"
    443439 *
    444  * These functions implement a presently undocumented interface 
     440 * These functions implement a presently undocumented interface
    445441 * used by the sysctl program to walk the tree, and get the type
    446442 * so it can print the value.
     
    552548                        name++;
    553549
    554                         if ((oid->oid_kind & CTLTYPE) != CTLTYPE_NODE) 
     550                        if ((oid->oid_kind & CTLTYPE) != CTLTYPE_NODE)
    555551                                break;
    556552
     
    569565
    570566static int
    571 sysctl_sysctl_next_ls(struct sysctl_oid_list *lsp, int *name, u_int namelen, 
     567sysctl_sysctl_next_ls(struct sysctl_oid_list *lsp, int *name, u_int namelen,
    572568        int *next, int *len, int level, struct sysctl_oid **oidpp)
    573569{
     
    583579
    584580                if (!namelen) {
    585                         if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE) 
     581                        if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
    586582                                return 0;
    587                         if (oidp->oid_handler) 
     583                        if (oidp->oid_handler)
    588584                                /* We really should call the handler here...*/
    589585                                return 0;
    590586                        lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
    591                         if (!sysctl_sysctl_next_ls(lsp, 0, 0, next+1, 
     587                        if (!sysctl_sysctl_next_ls(lsp, 0, 0, next+1,
    592588                                len, level+1, oidpp))
    593589                                return 0;
     
    604600                                return 0;
    605601                        lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
    606                         if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1, 
     602                        if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1,
    607603                                next+1, len, level+1, oidpp))
    608604                                return (0);
     
    616612
    617613                lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
    618                 if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1, next+1, 
     614                if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1, next+1,
    619615                        len, level+1, oidpp))
    620616                        return (0);
     
    662658        *len = 0;
    663659
    664         for (p = name; *p && *p != '.'; p++) 
     660        for (p = name; *p && *p != '.'; p++)
    665661                ;
    666662        i = *p;
     
    693689                oidp = SLIST_FIRST(lsp);
    694690                name = p+1;
    695                 for (p = name; *p && *p != '.'; p++) 
     691                for (p = name; *p && *p != '.'; p++)
    696692                                ;
    697693                i = *p;
     
    709705        struct sysctl_oid *op = 0;
    710706
    711         if (!req->newlen) 
     707        if (!req->newlen)
    712708                return ENOENT;
    713709        if (req->newlen >= MAXPATHLEN)  /* XXX arbitrary, undocumented */
     
    735731}
    736732
    737 SYSCTL_PROC(_sysctl, 3, name2oid, CTLFLAG_RW|CTLFLAG_ANYBODY, 0, 0, 
     733SYSCTL_PROC(_sysctl, 3, name2oid, CTLFLAG_RW|CTLFLAG_ANYBODY, 0, 0,
    738734        sysctl_sysctl_name2oid, "I", "");
    739735
     
    979975        req.oldfunc = sysctl_old_kernel;
    980976        req.newfunc = sysctl_new_kernel;
    981         req.lock = 1;
     977        req.lock = REQ_LOCKED;
    982978
    983979        SYSCTL_LOCK();
     
    985981        error = sysctl_root(0, name, namelen, &req);
    986982
    987         if (req.lock == 2)
     983        if (req.lock == REQ_WIRED)
    988984#ifdef __rtems__
    989985    printf ("kern_sysctl: vsunlock needs to be called!\n");
     
    991987                vsunlock(req.oldptr, req.oldlen);
    992988#endif
    993    
     989
    994990        SYSCTL_UNLOCK();
    995991
     
    10851081sysctl_wire_old_buffer(struct sysctl_req *req, size_t len)
    10861082{
    1087         if (req->lock == 1 && req->oldptr && req->oldfunc == sysctl_old_user) {
     1083        if (req->lock == REQ_LOCKED && req->oldptr &&
     1084            req->oldfunc == sysctl_old_user) {
    10881085#ifndef __rtems__
    10891086                vslock(req->oldptr, req->oldlen);
    10901087#endif
    1091                 req->lock = 2;
     1088                req->lock = REQ_WIRED;
    10921089        }
    10931090}
     
    11061103                        indx++;
    11071104                        if (oid->oid_kind & CTLFLAG_NOLOCK)
    1108                                 req->lock = 0;
     1105                                req->lock = REQ_UNLOCKED;
    11091106                        if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
    11101107                                if (oid->oid_handler != NULL ||
     
    11701167                        return (error);
    11711168        }
    1172  
     1169
    11731170        /* Is this sysctl writable by only privileged users? */
    11741171        if (req->newptr && !(oid->oid_kind & CTLFLAG_ANYBODY)) {
     
    11841181        }
    11851182#endif
    1186  
     1183
    11871184        if (!oid->oid_handler)
    11881185                return EINVAL;
     
    12851282        req.oldfunc = sysctl_old_user;
    12861283        req.newfunc = sysctl_new_user;
    1287         req.lock = 1;
     1284        req.lock = REQ_LOCKED;
    12881285
    12891286        SYSCTL_LOCK();
     
    13051302        req = req2;
    13061303#ifndef __rtems__
    1307         if (req.lock == 2)
     1304        if (req.lock == REQ_WIRED)
    13081305                vsunlock(req.oldptr, req.oldlen);
    13091306#endif
    1310  
     1307
    13111308        SYSCTL_UNLOCK();
    13121309
     
    14411438        case KINFO_METER:
    14421439                name[0] = CTL_VM;
    1443                 name[1] = VM_METER;
     1440                name[1] = VM_TOTAL;
    14441441                error = userland_sysctl(td, name, 2, uap->where, uap->size,
    14451442                        0, 0, 0, &size);
  • cpukit/libnetworking/sys/sysctl.h

    r429ba3b r0739963  
    9494 * be implemented.
    9595 * e.g. SYSCTL_INT(_parent, OID_AUTO, name, CTLFLAG_RW, &variable, 0, "");
    96  */ 
     96 */
    9797#define OID_AUTO        (-1)
    9898
     
    107107        struct sysctl_req *req
    108108
     109/* definitions for sysctl_req 'lock' member */
     110#define REQ_UNLOCKED    0       /* not locked and not wired */
     111#define REQ_LOCKED      1       /* locked and not wired */
     112#define REQ_WIRED       2       /* locked and wired */
     113
    109114/*
    110115 * This describes the access space for a sysctl request.  This is needed
     
    113118struct sysctl_req {
    114119        struct thread   *td;            /* used for access checking */
    115         int             lock;
     120        int             lock;           /* locking/wiring state */
    116121        void            *oldptr;
    117122        size_t          oldlen;
     
    329334#define KERN_NISDOMAINNAME      22      /* string: YP domain name */
    330335#define KERN_UPDATEINTERVAL     23      /* int: update process sleep time */
    331 #define KERN_OSRELDATE          24      /* int: OS release date */
     336#define KERN_OSRELDATE          24      /* int: kernel release date */
    332337#define KERN_NTP_PLL            25      /* node: NTP PLL control */
    333338#define KERN_BOOTFILE           26      /* string: name of booted kernel */
Note: See TracChangeset for help on using the changeset viewer.