Diff for /src/lib/libkvm/kvm.c between versions 1.3 and 1.4

version 1.3, 2003/11/12 20:21:30 version 1.4, 2004/04/11 21:28:03
Line 62 Line 62
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   #include <stdarg.h>
 #include <unistd.h>  #include <unistd.h>
   
 #include "kvm_private.h"  #include "kvm_private.h"
Line 70 Line 71
 int __fdnlist           (int, struct nlist *);  int __fdnlist           (int, struct nlist *);
   
 char *  char *
kvm_geterr(kd)kvm_geterr(kvm_t *kd)
        kvm_t *kd; 
 {  {
         return (kd->errbuf);          return (kd->errbuf);
 }  }
   
 #if __STDC__  
 #include <stdarg.h>  
 #else  
 #include <varargs.h>  
 #endif  
   
 /*  /*
  * Report an error using printf style arguments.  "program" is kd->program   * Report an error using printf style arguments.  "program" is kd->program
  * on hard errors, and 0 on soft errors, so that under sun error emulation,   * on hard errors, and 0 on soft errors, so that under sun error emulation,
Line 89  kvm_geterr(kd) Line 83  kvm_geterr(kd)
  * generate tons of error messages when trying to access bogus pointers).   * generate tons of error messages when trying to access bogus pointers).
  */   */
 void  void
 #if __STDC__  
 _kvm_err(kvm_t *kd, const char *program, const char *fmt, ...)  _kvm_err(kvm_t *kd, const char *program, const char *fmt, ...)
 #else  
 _kvm_err(kd, program, fmt, va_alist)  
         kvm_t *kd;  
         char *program, *fmt;  
         va_dcl  
 #endif  
 {  {
         va_list ap;          va_list ap;
   
 #ifdef __STDC__  
         va_start(ap, fmt);          va_start(ap, fmt);
 #else  
         va_start(ap);  
 #endif  
         if (program != NULL) {          if (program != NULL) {
                 (void)fprintf(stderr, "%s: ", program);                  (void)fprintf(stderr, "%s: ", program);
                 (void)vfprintf(stderr, fmt, ap);                  (void)vfprintf(stderr, fmt, ap);
Line 117  _kvm_err(kd, program, fmt, va_alist) Line 100  _kvm_err(kd, program, fmt, va_alist)
 }  }
   
 void  void
 #if __STDC__  
 _kvm_syserr(kvm_t *kd, const char *program, const char *fmt, ...)  _kvm_syserr(kvm_t *kd, const char *program, const char *fmt, ...)
 #else  
 _kvm_syserr(kd, program, fmt, va_alist)  
         kvm_t *kd;  
         char *program, *fmt;  
         va_dcl  
 #endif  
 {  {
         va_list ap;          va_list ap;
        register int n;        int n;
   
 #if __STDC__  
         va_start(ap, fmt);          va_start(ap, fmt);
 #else  
         va_start(ap);  
 #endif  
         if (program != NULL) {          if (program != NULL) {
                 (void)fprintf(stderr, "%s: ", program);                  (void)fprintf(stderr, "%s: ", program);
                 (void)vfprintf(stderr, fmt, ap);                  (void)vfprintf(stderr, fmt, ap);
Line 150  _kvm_syserr(kd, program, fmt, va_alist) Line 122  _kvm_syserr(kd, program, fmt, va_alist)
 }  }
   
 void *  void *
_kvm_malloc(kd, n)_kvm_malloc(kvm_t *kd, size_t n)
        register kvm_t *kd; 
        register size_t n; 
 {  {
         void *p;          void *p;
   
Line 163  _kvm_malloc(kd, n) Line 133  _kvm_malloc(kd, n)
 }  }
   
 static kvm_t *  static kvm_t *
_kvm_open(kd, uf, mf, flag, errout)_kvm_open(kvm_t *kd, const char *uf, const char *mf, int flag, char *errout)
        register kvm_t *kd; 
        const char *uf; 
        const char *mf; 
        int flag; 
        char *errout; 
 {  {
         struct stat st;          struct stat st;
   
Line 257  failed: Line 222  failed:
 }  }
   
 kvm_t *  kvm_t *
kvm_openfiles(uf, mf, sf, flag, errout)kvm_openfiles(const char *uf, const char *mf, const char *sf, int flag,
        const char *uf;              char *errout)
        const char *mf; 
        const char *sf; 
        int flag; 
        char *errout; 
 {  {
        register kvm_t *kd;        kvm_t *kd;
   
         if ((kd = malloc(sizeof(*kd))) == NULL) {          if ((kd = malloc(sizeof(*kd))) == NULL) {
                 (void)strlcpy(errout, strerror(errno), _POSIX2_LINE_MAX);                  (void)strlcpy(errout, strerror(errno), _POSIX2_LINE_MAX);
Line 276  kvm_openfiles(uf, mf, sf, flag, errout) Line 237  kvm_openfiles(uf, mf, sf, flag, errout)
 }  }
   
 kvm_t *  kvm_t *
kvm_open(uf, mf, sf, flag, errstr)kvm_open(const char *uf, const char *mf, const char *sf, int flag,
        const char *uf;         const char *errstr)
        const char *mf; 
        const char *sf; 
        int flag; 
        const char *errstr; 
 {  {
        register kvm_t *kd;        kvm_t *kd;
   
         if ((kd = malloc(sizeof(*kd))) == NULL) {          if ((kd = malloc(sizeof(*kd))) == NULL) {
                 if (errstr != NULL)                  if (errstr != NULL)
Line 297  kvm_open(uf, mf, sf, flag, errstr) Line 254  kvm_open(uf, mf, sf, flag, errstr)
 }  }
   
 int  int
kvm_close(kd)kvm_close(kvm_t *kd)
        kvm_t *kd; 
 {  {
        register int error = 0;        int error = 0;
   
         if (kd->pmfd >= 0)          if (kd->pmfd >= 0)
                 error |= close(kd->pmfd);                  error |= close(kd->pmfd);
Line 320  kvm_close(kd) Line 276  kvm_close(kd)
 }  }
   
 int  int
kvm_nlist(kd, nl)kvm_nlist(kvm_t *kd, struct nlist *nl)
        kvm_t *kd; 
        struct nlist *nl; 
 {  {
        register struct nlist *p;        struct nlist *p;
        register int nvalid;        int nvalid;
         struct kld_sym_lookup lookup;          struct kld_sym_lookup lookup;
   
         /*          /*
Line 365  kvm_nlist(kd, nl) Line 319  kvm_nlist(kd, nl)
 }  }
   
 ssize_t  ssize_t
kvm_read(kd, kva, buf, len)kvm_read(kvm_t *kd, u_long kva, void *buf, size_t len)
        kvm_t *kd; 
        register u_long kva; 
        register void *buf; 
        register size_t len; 
 {  {
        register int cc;        int cc;
        register void *cp;        void *cp;
   
         if (ISALIVE(kd)) {          if (ISALIVE(kd)) {
                 /*                  /*
Line 429  kvm_read(kd, kva, buf, len) Line 379  kvm_read(kd, kva, buf, len)
 }  }
   
 ssize_t  ssize_t
kvm_write(kd, kva, buf, len)kvm_write(kvm_t *kd, u_long kva, const void *buf, size_t len)
        kvm_t *kd; 
        register u_long kva; 
        register const void *buf; 
        register size_t len; 
 {  {
        register int cc;        int cc;
   
         if (ISALIVE(kd)) {          if (ISALIVE(kd)) {
                 /*                  /*

Removed from v.1.3  
changed lines
  Added in v.1.4