[BACK]Return to kvm.c CVS log [TXT] [DIR] Up to [DragonFly] / src / lib / libkvm

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