workbench/c/Avail.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Avail CLI command
   6     Lang: English
   7 */
   8
   9 /******************************************************************************
  10
  11
  12     NAME
  13
  14         Avail [CHIP | FAST | TOTAL | FLUSH] [H | HUMAN]
  15
  16     SYNOPSIS
  17
  18         CHIP/S, FAST/S, TOTAL/S, FLUSH/S, H=HUMAN/S
  19
  20     LOCATION
  21
  22         Workbench:C
  23
  24     FUNCTION
  25
  26         Give a summary of the memory usage and availability in the system.
  27         To free up unused memory that still may be allocated (libraries,
  28         devices, fonts and such present in memory but whcih are currently
  29         not in use), use the FLUSH option.
  30
  31     INPUTS
  32
  33         CHIP   --  show only "chip" memory
  34         FAST   --  show only "fast" memory
  35         TOTAL  --  show information on memory regardless of type
  36         FLUSH  --  remove unnecessary things residing in memory
  37         HUMAN  --  display more human-readable values (gigabytes as "G",
  38                    megabytes as "M", kilobytes as "K")
  39
  40     RESULT
  41
  42     NOTES
  43
  44         "Chip" and "fast" memory are associated with the Amiga computer
  45         and may not be applicable on your hardware platform.
  46
  47     EXAMPLE
  48
  49     BUGS
  50
  51     SEE ALSO
  52
  53     INTERNALS
  54
  55     HISTORY
  56
  57 ******************************************************************************/
  58
  59 #include <exec/execbase.h>
  60 #include <exec/memory.h>
  61 #include <proto/exec.h>
  62 #include <dos/dos.h>
  63 #include <proto/dos.h>
  64 #include <utility/tagitem.h>
  65 #include <string.h>
  66
  67 static const char version[] = "$VER: Avail 42.0 (13.9.2005)\n";
  68
  69
  70 #define  ARG_TEMPLATE  "CHIP/S,FAST/S,TOTAL/S,FLUSH/S,H=HUMAN/S"
  71
  72 enum
  73 {
  74     ARG_CHIP = 0,
  75     ARG_FAST,
  76     ARG_TOTAL,
  77     ARG_FLUSH,
  78     ARG_HUMAN,
  79     NOOFARGS
  80 };
  81
  82 LONG printm(CONST_STRPTR head, ULONG *array, LONG num);
  83
  84 int __nocommandline = 1;
  85
  86 BOOL aHuman;
  87
  88 int main(void)
  89 {
  90     IPTR           args[NOOFARGS] = { (IPTR)FALSE,
  91                                       (IPTR)FALSE,
  92                                       (IPTR)FALSE,
  93                                       (IPTR)FALSE,
  94                                       (IPTR)FALSE };
  95     struct RDArgs *rda;
  96     LONG           error = 0;
  97     BOOL bPrintErr = TRUE;
  98     rda = ReadArgs(ARG_TEMPLATE, args, NULL);
  99
 100     if (rda != NULL)
 101     {
 102         UWORD typeCount = 0;
 103         BOOL  aChip  = (BOOL)args[ARG_CHIP];
 104         BOOL  aFast  = (BOOL)args[ARG_FAST];
 105         BOOL  aTotal = (BOOL)args[ARG_TOTAL];
 106         BOOL  aFlush = (BOOL)args[ARG_FLUSH];
 107         aHuman = (BOOL)args[ARG_HUMAN];
 108
 109         if (aChip)
 110         {
 111             typeCount++;
 112         }
 113         if (aFast)
 114         {
 115             typeCount++;
 116         }
 117         if (aTotal)
 118         {
 119             typeCount++;
 120         }
 121
 122         ULONG chip[4], fast[4], total[4];
 123
 124         if (typeCount > 1)
 125         {
 126             FPuts(Output(), "Only one of CHIP, FAST or TOTAL allowed\n");
 127             bPrintErr = FALSE;
 128             FreeArgs(rda);
 129
 130             return RETURN_FAIL;
 131         }
 132         else
 133         {
 134             if (aFlush)
 135             {
 136                     APTR Mem;
 137
 138                     Mem = AllocMem(0x7ffffff0, MEMF_PUBLIC);
 139                     if (Mem)
 140                         FreeMem(Mem, 0x7ffffff0);
 141             }
 142
 143             if(aChip)
 144             {
 145
 146                 chip[0] = AvailMem(MEMF_CHIP);
 147
 148                 if (printm(NULL, chip, 1) < 0)
 149                 {
 150                     error = RETURN_ERROR;
 151                 }
 152             }
 153             else if(aFast)
 154             {
 155                 fast[0] = AvailMem(MEMF_FAST);
 156
 157                 if (printm(NULL, fast, 1) < 0)
 158                 {
 159                     error = RETURN_ERROR;
 160                 }
 161             }
 162             else if (aTotal)
 163             {
 164                 total[0] = AvailMem(MEMF_ANY);
 165
 166                 if (printm(NULL, total, 1) < 0)
 167                 {
 168                     error = RETURN_ERROR;
 169                 }
 170             }
 171             else
 172             {
 173                 Forbid();
 174
 175                 chip[0] = AvailMem(MEMF_CHIP);
 176                 chip[2] = AvailMem(MEMF_CHIP | MEMF_TOTAL);
 177                 chip[3] = AvailMem(MEMF_CHIP | MEMF_LARGEST);
 178                 chip[1] = chip[2] - chip[0];
 179                 fast[0] = AvailMem(MEMF_FAST);
 180                 fast[2] = AvailMem(MEMF_FAST | MEMF_TOTAL);
 181                 fast[3] = AvailMem(MEMF_FAST | MEMF_LARGEST);
 182                 fast[1] = fast[2] - fast[0];
 183                 total[0] = AvailMem(MEMF_ANY);
 184                 total[2] = AvailMem(MEMF_ANY | MEMF_TOTAL);
 185                 total[3] = AvailMem(MEMF_ANY | MEMF_LARGEST);
 186                 total[1] = total[2] - total[0];
 187
 188                 Permit();
 189
 190                 if (PutStr("Type   Available    In-Use   Maximum   Largest\n") < 0 ||
 191                     printm("chip", chip, 4) < 0 ||
 192                     printm("fast", fast, 4) < 0 ||
 193                     printm("total", total, 4) < 0)
 194                 {
 195                     error = RETURN_ERROR;
 196                 }
 197             }
 198         }
 199
 200         FreeArgs(rda);
 201     }
 202     else
 203     {
 204         error = RETURN_FAIL;
 205     }
 206
 207     if(error != RETURN_OK && bPrintErr)
 208     {
 209         PrintFault(IoErr(), "Avail");
 210     }
 211
 212     return error;
 213 }
 214
 215 static
 216 void fmtlarge(UBYTE *buf, ULONG num)
 217 {
 218     UQUAD d;
 219     UBYTE ch;
 220     struct
 221     {
 222         ULONG val;
 223         LONG  dec;
 224     } array =
 225     {
 226         num,
 227         0
 228     };
 229
 230     if (num >= 1073741824)
 231     {
 232         array.val = num >> 30;
 233         d = ((UQUAD)num * 10 + 536870912) / 1073741824;
 234         array.dec = d % 10;
 235         ch = 'G';
 236     }
 237     else if (num >= 1048576)
 238     {
 239         array.val = num >> 20;
 240         d = ((UQUAD)num * 10 + 524288) / 1048576;
 241         array.dec = d % 10;
 242         ch = 'M';
 243     }
 244     else if (num >= 1024)
 245     {
 246         array.val = num >> 10;
 247         d = (num * 10 + 512) / 1024;
 248         array.dec = d % 10;
 249         ch = 'K';
 250     }
 251     else
 252     {
 253         array.val = num;
 254         array.dec = 0;
 255         d = 0;
 256         ch = 'B';
 257     }
 258
 259     if (!array.dec && (d > array.val * 10))
 260     {
 261         array.val++;
 262     }
 263
 264     RawDoFmt(array.dec ? "%lu.%lu" : "%lu", &array, NULL, buf);
 265     while (*buf) { buf++; }
 266     *buf++ = ch;
 267     *buf   = '\0';
 268 }
 269
 270 LONG printm(CONST_STRPTR head, ULONG *array, LONG num)
 271 {
 272     LONG res = -1;
 273     CONST_STRPTR fmt;
 274     UBYTE buf[10];
 275
 276     if (head)
 277     {
 278         LONG len = 16 - strlen(head);
 279         RawDoFmt(aHuman ? "%%%lds" : "%%%ldlu", &len, NULL, buf);
 280         fmt = buf;
 281         PutStr(head);
 282     }
 283     else
 284     {
 285         fmt = aHuman ? "%9s" : "%9lu";
 286     }
 287
 288     if (aHuman)
 289     {
 290         if (num == 1)
 291         {
 292             fmtlarge(buf, *array);
 293             res = PutStr(buf);
 294         }
 295         else
 296         {
 297             while (num--)
 298             {
 299                 UBYTE tmp[10];
 300
 301                 fmtlarge(tmp, *array);
 302                 res = Printf(fmt, (ULONG) tmp);
 303                 if (res < 0)
 304                     break;
 305
 306                 fmt = " %9s";
 307                 array++;
 308             }
 309         }
 310     }
 311     else
 312     {
 313         if (num == 1)
 314         {
 315             res = VPrintf("%lu", array);
 316         }
 317         else
 318         {
 319             while (num--)
 320             {
 321                 res = VPrintf(fmt, array);
 322                 if (res < 0)
 323                     break;
 324
 325                 fmt = " %9lu";
 326                 array++;
 327             }
 328         }
 329     }
 330     PutStr("\n");
 331
 332     return res;
 333 }