workbench/c/Avail.c

   1 /*
   2     Copyright © 1995-2016, 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         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 <aros/cpu.h> // for __WORDSIZE
  60 #include <exec/execbase.h>
  61 #include <exec/memory.h>
  62 #include <proto/exec.h>
  63 #include <dos/dos.h>
  64 #include <proto/dos.h>
  65 #include <utility/tagitem.h>
  66 #include <string.h>
  67
  68 const TEXT version[] = "$VER: Avail 42.2 (24.2.2016)\n";
  69
  70 #if (__WORDSIZE == 64)
  71 #define AVAIL_ARCHSTR   "%9s"
  72 #define AVAIL_ARCHVAL   "%9iu"
  73 #else
  74 #define AVAIL_ARCHSTR   "%12s"
  75 #define AVAIL_ARCHVAL   "%12iu"
  76 #endif
  77
  78 #define  ARG_TEMPLATE  "CHIP/S,FAST/S,TOTAL/S,FLUSH/S,H=HUMAN/S"
  79
  80 enum
  81 {
  82     ARG_CHIP = 0,
  83     ARG_FAST,
  84     ARG_TOTAL,
  85     ARG_FLUSH,
  86     ARG_HUMAN,
  87     NOOFARGS
  88 };
  89
  90 LONG printm(CONST_STRPTR head, IPTR *array, LONG num);
  91
  92 int __nocommandline = 1;
  93
  94 BOOL aHuman;
  95
  96 /* Allocate all memory (even for >2G systems), then free it.
  97  * This will force all expungable items out of memory
  98  */
  99 static void FlushMem(struct ExecBase *SysBase)
 100 {
 101     APTR Mem;
 102
 103     Mem = AllocMem(0x7ffffff0, MEMF_PUBLIC);
 104     if (Mem) {
 105         FlushMem(SysBase);
 106         FreeMem(Mem, 0x7ffffff0);
 107     }
 108 }
 109
 110 int main(void)
 111 {
 112     IPTR           args[NOOFARGS] = { (IPTR)FALSE,
 113                                       (IPTR)FALSE,
 114                                       (IPTR)FALSE,
 115                                       (IPTR)FALSE,
 116                                       (IPTR)FALSE };
 117     struct RDArgs *rda;
 118     LONG           error = 0;
 119     BOOL bPrintErr = TRUE;
 120     rda = ReadArgs(ARG_TEMPLATE, args, NULL);
 121
 122     if (rda != NULL)
 123     {
 124         UWORD typeCount = 0;
 125         BOOL  aChip  = (BOOL)args[ARG_CHIP];
 126         BOOL  aFast  = (BOOL)args[ARG_FAST];
 127         BOOL  aTotal = (BOOL)args[ARG_TOTAL];
 128         BOOL  aFlush = (BOOL)args[ARG_FLUSH];
 129         aHuman = (BOOL)args[ARG_HUMAN];
 130
 131         if (aChip)
 132         {
 133             typeCount++;
 134         }
 135         if (aFast)
 136         {
 137             typeCount++;
 138         }
 139         if (aTotal)
 140         {
 141             typeCount++;
 142         }
 143
 144         IPTR chip[4], fast[4], total[4];
 145
 146         if (typeCount > 1)
 147         {
 148             FPuts(Output(), "Only one of CHIP, FAST or TOTAL allowed\n");
 149             bPrintErr = FALSE;
 150             FreeArgs(rda);
 151
 152             return RETURN_FAIL;
 153         }
 154         else
 155         {
 156             if (aFlush)
 157             {
 158                 FlushMem(SysBase);
 159             }
 160
 161             if(aChip)
 162             {
 163
 164                 chip[0] = AvailMem(MEMF_CHIP);
 165
 166                 if (printm(NULL, chip, 1) < 0)
 167                 {
 168                     error = RETURN_ERROR;
 169                 }
 170             }
 171             else if(aFast)
 172             {
 173                 fast[0] = AvailMem(MEMF_FAST);
 174
 175                 if (printm(NULL, fast, 1) < 0)
 176                 {
 177                     error = RETURN_ERROR;
 178                 }
 179             }
 180             else if (aTotal)
 181             {
 182                 total[0] = AvailMem(MEMF_ANY);
 183
 184                 if (printm(NULL, total, 1) < 0)
 185                 {
 186                     error = RETURN_ERROR;
 187                 }
 188             }
 189             else
 190             {
 191                 Forbid();
 192
 193                 chip[0] = AvailMem(MEMF_CHIP);
 194                 chip[2] = AvailMem(MEMF_CHIP | MEMF_TOTAL);
 195                 chip[3] = AvailMem(MEMF_CHIP | MEMF_LARGEST);
 196                 chip[1] = chip[2] - chip[0];
 197                 fast[0] = AvailMem(MEMF_FAST);
 198                 fast[2] = AvailMem(MEMF_FAST | MEMF_TOTAL);
 199                 fast[3] = AvailMem(MEMF_FAST | MEMF_LARGEST);
 200                 fast[1] = fast[2] - fast[0];
 201                 total[0] = AvailMem(MEMF_ANY);
 202                 total[2] = AvailMem(MEMF_ANY | MEMF_TOTAL);
 203                 total[3] = AvailMem(MEMF_ANY | MEMF_LARGEST);
 204                 total[1] = total[2] - total[0];
 205
 206                 Permit();
 207
 208                 if (PutStr("Type   Available    In-Use   Maximum   Largest\n") < 0 ||
 209                     printm("chip", chip, 4) < 0 ||
 210                     printm("fast", fast, 4) < 0 ||
 211                     printm("total", total, 4) < 0)
 212                 {
 213                     error = RETURN_ERROR;
 214                 }
 215             }
 216         }
 217
 218         FreeArgs(rda);
 219     }
 220     else
 221     {
 222         error = RETURN_FAIL;
 223     }
 224
 225     if(error != RETURN_OK && bPrintErr)
 226     {
 227         PrintFault(IoErr(), "Avail");
 228     }
 229
 230     return error;
 231 }
 232
 233 static
 234 void fmtlarge(UBYTE *buf, IPTR num)
 235 {
 236     UQUAD d;
 237     UBYTE ch;
 238     struct
 239     {
 240         IPTR val;
 241         IPTR  dec;
 242     } array =
 243     {
 244         num,
 245         0
 246     };
 247
 248     if (num >= 0x40000000)
 249     {
 250         array.val = num >> 30;
 251         d = ((UQUAD)num * 100 + 0x20000000) / 0x40000000;
 252         array.dec = d % 100;
 253         ch = 'G';
 254     }
 255     else if (num >= 0x100000)
 256     {
 257         array.val = num >> 20;
 258         d = ((UQUAD)num * 100 + 0x80000) / 0x100000;
 259         array.dec = d % 100;
 260         ch = 'M';
 261     }
 262     else if (num >= 0x400)
 263     {
 264         array.val = num >> 10;
 265         d = (num * 100 + 0x200) / 0x400;
 266         array.dec = d % 100;
 267         ch = 'K';
 268     }
 269     else
 270     {
 271         array.val = num;
 272         array.dec = 0;
 273         d = 0;
 274         ch = 'B';
 275     }
 276
 277     if (!array.dec && (d > array.val * 100))
 278     {
 279         array.val++;
 280     }
 281
 282     RawDoFmt(array.dec ? "%iu.%02iu" : "%iu", (RAWARG)&array, NULL, buf);
 283     while (*buf) { buf++; }
 284     *buf++ = ch;
 285     *buf   = '\0';
 286 }
 287
 288 LONG printm(CONST_STRPTR head, IPTR *array, LONG num)
 289 {
 290     LONG res = -1;
 291     CONST_STRPTR fmt;
 292     UBYTE buf[10];
 293
 294     if (head)
 295     {
 296         ULONG len = 16 - strlen(head);
 297         RawDoFmt(aHuman ? "%%%lds" : "%%%ldiu", (RAWARG)&len, NULL, buf);
 298         fmt = buf;
 299         PutStr(head);
 300     }
 301     else
 302     {
 303         fmt = aHuman ? AVAIL_ARCHSTR : AVAIL_ARCHVAL;
 304     }
 305
 306     if (aHuman)
 307     {
 308         if (num == 1)
 309         {
 310             fmtlarge(buf, *array);
 311             res = PutStr(buf);
 312         }
 313         else
 314         {
 315             while (num--)
 316             {
 317                 UBYTE tmp[10];
 318
 319                 fmtlarge(tmp, *array);
 320                 res = Printf(fmt, tmp);
 321                 if (res < 0)
 322                     break;
 323
 324                 fmt = " " AVAIL_ARCHSTR;
 325                 array++;
 326             }
 327         }
 328     }
 329     else
 330     {
 331         if (num == 1)
 332         {
 333             res = VPrintf("%iu", (RAWARG)array);
 334         }
 335         else
 336         {
 337             while (num--)
 338             {
 339                 res = VPrintf(fmt, (RAWARG)array);
 340                 if (res < 0)
 341                     break;
 342
 343                 fmt = " " AVAIL_ARCHVAL;
 344                 array++;
 345             }
 346         }
 347     }
 348     PutStr("\n");
 349
 350     return res;
 351 }