proc/smaps.c

   1 #if 0
   2 #include "procps.h"
   3 #include <fcntl.h>
   4 #include <sys/stat.h>
   5 #include <sys/types.h>
   6 #include <unistd.h>
   7 #include <string.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include "procps.h"
  11
  12 struct smap_entry {
  13         unsigned KLONG start;
  14         unsigned KLONG beyond;
  15         long long offset;
  16         char flags[8];
  17         unsigned dev_major;
  18         unsigned dev_minor;
  19         unsigned long long inode;
  20
  21         unsigned long rss;
  22         unsigned long pss;
  23         unsigned long sclean;
  24         unsigned long sdirty;
  25         unsigned long pclean;
  26         unsigned long pdirty;
  27         unsigned long ref;
  28         unsigned long swap;
  29 };
  30
  31
  32 ////////////////////////////////////////////////////////////////////////////////
  33 // This code will surely make normal programmers cry. I need speed though,
  34 // and /proc/*/smaps should make anybody cry. (WTF kind of brain damage...?)
  35
  36 struct smap_summary {
  37         unsigned long size;
  38         unsigned long rss;
  39         unsigned long pss;
  40         unsigned long sclean;
  41         unsigned long sdirty;
  42         unsigned long pclean;
  43         unsigned long pdirty;
  44         unsigned long ref;
  45         unsigned long swap;
  46 };
  47
  48 struct ssjt {
  49         char str[16];
  50         int len;
  51         int offset;
  52 };
  53
  54 #define JTE(o,x) {#x,sizeof(#x)-1,o}
  55
  56 void get_smap_sums(struct smap_summary *restrict ss, const char *restrict const filename){
  57         static struct ssjt table[] = {
  58                 JTE(-1,default),
  59                 JTE( 1,Rss),
  60                 JTE(-1,default),
  61                 JTE( 2,Pss),
  62                 JTE( 8,Swap),
  63                 JTE( 5,Private_Clean),
  64                 JTE( 6,Private_Dirty),
  65                 JTE(-1,default),
  66                 JTE( 7,Referenced),
  67                 JTE(-1,default),
  68                 JTE( 0,Size),
  69                 JTE(-1,default),
  70                 JTE(-1,default),
  71                 JTE(-1,default),
  72                 JTE(-1,default),
  73                 JTE(-1,default), // KernelPageSize would go here
  74                 JTE(-1,default),
  75                 JTE(-1,default),
  76                 JTE( 4,Shared_Dirty),
  77                 JTE(-1,default),
  78                 JTE(-1,default),
  79                 JTE(-1,default),
  80                 JTE(-1,default),
  81                 JTE( 3,Shared_Clean),
  82                 JTE(-1,default),
  83                 JTE(-1,default),
  84                 JTE(-1,default),
  85                 JTE(-1,default),
  86                 JTE(-1,default),
  87                 JTE(-1,default),
  88                 JTE(-1,default),
  89                 JTE(-1,default),
  90         };
  91         char buf[20480];
  92         int p1 = 0;
  93         int p2 = 0;
  94         memset(ss,0,sizeof *ss);
  95         int fd = open(filename,O_RDONLY);
  96         if(fd==-1)
  97                 return;
  98         for(;;){
  99                 char *nlp = memchr(buf+p1,'\n',p2-p1);
 100                 if(!nlp){
 101                         if(p1){
 102                                 // the memmove should never do anything, because the
 103                                 // kernel seems to give us the greatest number of
 104                                 // complete lines of text that fit in a single page
 105                                 // (and thus p2-p1 is zero)
 106                                 memmove(buf,buf+p1,p2-p1);
 107                                 p2 -= p1;
 108                                 p1 = 0;
 109                         }
 110                         ssize_t rb = read(fd,buf+p1,sizeof buf - p1);
 111                         if(rb < 1)
 112                                 break;
 113                         p2 += rb;
 114                         nlp = memchr(buf+p1,'\n',p2-p1);
 115                         if(!nlp)
 116                                 break;
 117                 }
 118                 char *s = buf+p1;
 119                 int len = nlp-s;
 120                 p1 += len+1;
 121                 if(len<27)
 122                         continue;
 123 //printf("j      <%13.13s>\n",s);
 124                 if(s[0]<'A' || s[0]>'Z')
 125                         continue;
 126                 unsigned hash = ( (s[8]&15) + (s[1]&15) ) ^ (s[0]&3);
 127                 hash &= 31;
 128 //printf("x   %2d <%13.13s>\n",hash,s);
 129                 if(s[table[hash].len] != ':')
 130                         continue;
 131 //printf("y   %2d <%13.13s>\n",hash,s);
 132                 if(memcmp(table[hash].str,s,table[hash].len))
 133                         continue;
 134 //printf("z   %2d <%13.13s>\n",hash,s);
 135                 s += table[hash].len;
 136                 while(*++s==' ')
 137                         ;
 138                 unsigned long ul = 0;
 139                 for(;;){
 140                         char c = *s++;
 141                         if(c != ' '){
 142                                 ul *= 10;
 143                                 ul += c-'0';
 144                                 continue;
 145                         }
 146                         break;
 147                 }
 148 //              if(table[hash].offset == 2)
 149 //                      printf("Pss:%20lu kB\n",ul);
 150                 unsigned long *ulp = &ss->size + table[hash].offset;
 151                 *ulp += ul;
 152 //              memcpy(ss+table[hash].offset*sizeof(unsigned long), &ul, sizeof(unsigned long));
 153         }
 154         close(fd);
 155 }
 156
 157 int main(int argc, char *argv[]){
 158         struct smap_summary ss;
 159         get_smap_sums(&ss, argv[1]);
 160         printf("%9lu\n",ss.size);
 161         printf("%9lu\n",ss.rss);
 162         printf("%9lu\n",ss.pss);
 163         printf("%9lu\n",ss.sclean);
 164         printf("%9lu\n",ss.sdirty);
 165         printf("%9lu\n",ss.pclean);
 166         printf("%9lu\n",ss.pdirty);
 167         printf("%9lu\n",ss.ref);
 168         printf("%9lu\n",ss.swap);
 169         return 0;
 170 }
 171 #endif