src/mountlist.c

   1 /* mountlist.c -- return a list of mounted filesystems
   2    Copyright (C) 1991, 1992 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 #ifdef HAVE_CONFIG_H
  19 #include <config.h>
  20 #endif
  21
  22 #include <sys/types.h>
  23 #include <stdio.h>
  24 #include <fcntl.h>
  25
  26 #ifdef STDC_HEADERS
  27 #include <stdlib.h>
  28 #else
  29 void free (void *ptr);
  30 #endif
  31 #if defined(STDC_HEADERS) || defined(HAVE_STRING_H)
  32 #include <string.h>
  33 #else
  34 #include <strings.h>
  35 #endif
  36
  37 #ifdef HAVE_UNISTD_H
  38 #    include <unistd.h>
  39 #endif
  40
  41 #ifdef HAVE_SYS_PARAM_H
  42 #include <sys/param.h>
  43 #endif
  44
  45 #if defined (MOUNTED_GETFSSTAT) /* __alpha running OSF_1 */
  46 #include <sys/mount.h>
  47 #include <sys/fs_types.h>
  48 #endif                          /* MOUNTED_GETFSSTAT */
  49
  50 #ifdef MOUNTED_GETMNTENT1       /* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
  51 #include <mntent.h>
  52 #if !defined(MOUNTED)
  53 #if defined(MNT_MNTTAB)         /* HP-UX.  */
  54 #define MOUNTED MNT_MNTTAB
  55 #endif
  56 #if defined(MNTTABNAME)         /* Dynix.  */
  57 #define MOUNTED MNTTABNAME
  58 #endif
  59 #endif
  60 #endif
  61
  62 #ifdef MOUNTED_GETMNTINFO       /* 4.4BSD.  */
  63 #include <sys/mount.h>
  64 #endif
  65
  66 #ifdef MOUNTED_GETMNT           /* Ultrix.  */
  67 #include <sys/mount.h>
  68 #include <sys/fs_types.h>
  69 #endif
  70
  71 #ifdef MOUNTED_FREAD            /* SVR2.  */
  72 #include <mnttab.h>
  73 #endif
  74
  75 #ifdef MOUNTED_FREAD_FSTYP      /* SVR3.  */
  76 #include <mnttab.h>
  77 #include <sys/fstyp.h>
  78 #include <sys/statfs.h>
  79 #endif
  80
  81 #ifdef MOUNTED_GETMNTENT2       /* SVR4.  */
  82 #include <sys/mnttab.h>
  83 #endif
  84
  85 #ifdef MOUNTED_VMOUNT           /* AIX.  */
  86 #include <fshelp.h>
  87 #include <sys/vfs.h>
  88 #endif
  89
  90 #ifdef HAVE_SYS_STATFS_H
  91 #include <sys/statfs.h>
  92 #endif
  93
  94 #ifdef HAVE_INFOMOUNT_QNX
  95 #include <sys/disk.h>
  96 #include <sys/fsys.h>
  97 #endif
  98
  99 #include "global.h"
 100 #include "mountlist.h"
 101 #include "fsusage.h"
 102 #include "util.h"
 103
 104 /* void error (void);  FIXME -- needed? */
 105
 106 #ifdef DOLPHIN
 107 /* So special that it's not worth putting this in autoconf.  */
 108 #undef MOUNTED_FREAD_FSTYP
 109 #define MOUNTED_GETMNTTBL
 110 #endif
 111
 112 /* A mount table entry. */
 113 struct mount_entry
 114 {
 115   char *me_devname;             /* Device node pathname, including "/dev/". */
 116   char *me_mountdir;            /* Mount point directory pathname. */
 117   char *me_type;                /* "nfs", "4.2", etc. */
 118   dev_t me_dev;                 /* Device number of me_mountdir. */
 119   struct mount_entry *me_next;
 120 };
 121
 122 #ifdef HAVE_INFOMOUNT_LIST
 123
 124 static struct mount_entry *mount_list = NULL;
 125
 126 #ifdef MOUNTED_GETMNTENT1       /* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
 127 /* Return the value of the hexadecimal number represented by CP.
 128    No prefix (like '0x') or suffix (like 'h') is expected to be
 129    part of CP. */
 130
 131 static int xatoi (char *cp)
 132 {
 133     int val;
 134
 135     val = 0;
 136     while (*cp) {
 137         if (*cp >= 'a' && *cp <= 'f')
 138             val = val * 16 + *cp - 'a' + 10;
 139         else if (*cp >= 'A' && *cp <= 'F')
 140             val = val * 16 + *cp - 'A' + 10;
 141         else if (*cp >= '0' && *cp <= '9')
 142             val = val * 16 + *cp - '0';
 143         else
 144             break;
 145         cp++;
 146     }
 147     return val;
 148 }
 149 #endif /* MOUNTED_GETMNTENT1 */
 150
 151 #if defined (MOUNTED_GETMNTINFO) && !defined (HAVE_F_FSTYPENAME)
 152 static char *fstype_to_string (short t)
 153 {
 154     switch (t) {
 155     case MOUNT_UFS:
 156         return "ufs";
 157     case MOUNT_NFS:
 158         return "nfs";
 159 #ifdef MOUNT_PC
 160     case MOUNT_PC:
 161         return "pc";
 162 #endif
 163 #ifdef MOUNT_MFS
 164     case MOUNT_MFS:
 165         return "mfs";
 166 #endif
 167 #ifdef MOUNT_LO
 168     case MOUNT_LO:
 169         return "lo";
 170 #endif
 171 #ifdef MOUNT_TFS
 172     case MOUNT_TFS:
 173         return "tfs";
 174 #endif
 175 #ifdef MOUNT_TMP
 176     case MOUNT_TMP:
 177         return "tmp";
 178 #endif
 179     default:
 180         return "?";
 181     }
 182 }
 183 #endif /* MOUNTED_GETMNTINFO && !HAVE_F_FSTYPENAME */
 184
 185 #ifdef MOUNTED_VMOUNT           /* AIX.  */
 186 static char *
 187 fstype_to_string (int t)
 188 {
 189     struct vfs_ent *e;
 190
 191     e = getvfsbytype (t);
 192     if (!e || !e->vfsent_name)
 193         return "none";
 194     else
 195         return e->vfsent_name;
 196 }
 197 #endif /* MOUNTED_VMOUNT */
 198
 199 /* Return a list of the currently mounted filesystems, or NULL on error.
 200    Add each entry to the tail of the list so that they stay in order.
 201    If NEED_FS_TYPE is nonzero, ensure that the filesystem type fields in
 202    the returned list are valid.  Otherwise, they might not be.
 203    If ALL_FS is zero, do not return entries for filesystems that
 204    are automounter (dummy) entries.  */
 205
 206 static struct mount_entry *
 207 read_filesystem_list (int need_fs_type, int all_fs)
 208 {
 209     struct mount_entry *mlist;
 210     struct mount_entry *me;
 211     struct mount_entry *mtail;
 212
 213     /* Start the list off with a dummy entry. */
 214     me = (struct mount_entry *) malloc (sizeof (struct mount_entry));
 215     me->me_next = NULL;
 216     mlist = mtail = me;
 217
 218 #ifdef MOUNTED_GETMNTENT1       /* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
 219     {
 220         struct mntent *mnt;
 221         char *table = MOUNTED;
 222         FILE *fp;
 223         char *devopt;
 224
 225         fp = setmntent (table, "r");
 226         if (fp == NULL)
 227             return NULL;
 228
 229         while ((mnt = getmntent (fp))) {
 230             if (!all_fs && (!strcmp (mnt->mnt_type, "ignore")
 231                             || !strcmp (mnt->mnt_type, "auto")))
 232                 continue;
 233
 234             me = (struct mount_entry *) malloc (sizeof (struct mount_entry));
 235             me->me_devname = strdup (mnt->mnt_fsname);
 236             me->me_mountdir = strdup (mnt->mnt_dir);
 237             me->me_type = strdup (mnt->mnt_type);
 238             devopt = strstr (mnt->mnt_opts, "dev=");
 239             if (devopt) {
 240                 if (devopt[4] == '0' && (devopt[5] == 'x' || devopt[5] == 'X'))
 241                     me->me_dev = xatoi (devopt + 6);
 242                 else
 243                     me->me_dev = xatoi (devopt + 4);
 244             } else
 245                 me->me_dev = -1;        /* Magic; means not known yet. */
 246             me->me_next = NULL;
 247
 248             /* Add to the linked list. */
 249             mtail->me_next = me;
 250             mtail = me;
 251         }
 252
 253         if (endmntent (fp) == 0)
 254             return NULL;
 255     }
 256 #endif /* MOUNTED_GETMNTENT1 */
 257
 258 #ifdef MOUNTED_GETMNTINFO       /* 4.4BSD.  */
 259     {
 260         struct statfs *fsp;
 261         int entries;
 262
 263         entries = getmntinfo (&fsp, MNT_NOWAIT);
 264         if (entries < 0)
 265             return NULL;
 266         while (entries-- > 0) {
 267             me = (struct mount_entry *) malloc (sizeof (struct mount_entry));
 268             me->me_devname = strdup (fsp->f_mntfromname);
 269             me->me_mountdir = strdup (fsp->f_mntonname);
 270 #ifdef HAVE_F_FSTYPENAME
 271             me->me_type = strdup (fsp->f_fstypename);
 272 #else
 273             me->me_type = fstype_to_string (fsp->f_type);
 274 #endif
 275             me->me_dev = -1;    /* Magic; means not known yet. */
 276             me->me_next = NULL;
 277
 278             /* Add to the linked list. */
 279             mtail->me_next = me;
 280             mtail = me;
 281             fsp++;
 282         }
 283     }
 284 #endif /* MOUNTED_GETMNTINFO */
 285
 286 #ifdef MOUNTED_GETMNT           /* Ultrix.  */
 287     {
 288         int offset = 0;
 289         int val;
 290         struct fs_data fsd;
 291
 292         while ((val = getmnt (&offset, &fsd, sizeof (fsd), NOSTAT_MANY,
 293                               (char *) 0)) > 0) {
 294             me = (struct mount_entry *) malloc (sizeof (struct mount_entry));
 295             me->me_devname = strdup (fsd.fd_req.devname);
 296             me->me_mountdir = strdup (fsd.fd_req.path);
 297             me->me_type = gt_names[fsd.fd_req.fstype];
 298             me->me_dev = fsd.fd_req.dev;
 299             me->me_next = NULL;
 300
 301             /* Add to the linked list. */
 302             mtail->me_next = me;
 303             mtail = me;
 304         }
 305         if (val < 0)
 306             return NULL;
 307     }
 308 #endif /* MOUNTED_GETMNT */
 309
 310 #ifdef MOUNTED_GETFSSTAT        /* __alpha running OSF_1 */
 311     {
 312         int numsys, counter, bufsize;
 313         struct statfs *stats;
 314
 315         numsys = getfsstat ((struct statfs *) 0, 0L, MNT_WAIT);
 316         if (numsys < 0)
 317             return (NULL);
 318
 319         bufsize = (1 + numsys) * sizeof (struct statfs);
 320         stats = (struct statfs *) malloc (bufsize);
 321         numsys = getfsstat (stats, bufsize, MNT_WAIT);
 322
 323         if (numsys < 0) {
 324             free (stats);
 325             return (NULL);
 326         }
 327         for (counter = 0; counter < numsys; counter++) {
 328             me = (struct mount_entry *) malloc (sizeof (struct mount_entry));
 329             me->me_devname = strdup (stats[counter].f_mntfromname);
 330             me->me_mountdir = strdup (stats[counter].f_mntonname);
 331             me->me_type = mnt_names[stats[counter].f_type];
 332             me->me_dev = -1;    /* Magic; means not known yet. */
 333             me->me_next = NULL;
 334
 335             /* Add to the linked list. */
 336             mtail->me_next = me;
 337             mtail = me;
 338         }
 339
 340         free (stats);
 341     }
 342 #endif /* MOUNTED_GETFSSTAT */
 343
 344 #if defined (MOUNTED_FREAD) || defined (MOUNTED_FREAD_FSTYP)    /* SVR[23].  */
 345     {
 346         struct mnttab mnt;
 347         char *table = "/etc/mnttab";
 348         FILE *fp;
 349
 350         fp = fopen (table, "r");
 351         if (fp == NULL)
 352             return NULL;
 353
 354         while (fread (&mnt, sizeof mnt, 1, fp) > 0) {
 355             me = (struct mount_entry *) malloc (sizeof (struct mount_entry));
 356 #ifdef GETFSTYP                 /* SVR3.  */
 357             me->me_devname = strdup (mnt.mt_dev);
 358 #else
 359             me->me_devname = malloc (strlen (mnt.mt_dev) + 6);
 360             strcpy (me->me_devname, "/dev/");
 361             strcpy (me->me_devname + 5, mnt.mt_dev);
 362 #endif
 363             me->me_mountdir = strdup (mnt.mt_filsys);
 364             me->me_dev = -1;    /* Magic; means not known yet. */
 365             me->me_type = "";
 366 #ifdef GETFSTYP                 /* SVR3.  */
 367             if (need_fs_type) {
 368                 struct statfs fsd;
 369                 char typebuf[FSTYPSZ];
 370
 371                 if (statfs (me->me_mountdir, &fsd, sizeof fsd, 0) != -1
 372                     && sysfs (GETFSTYP, fsd.f_fstyp, typebuf) != -1)
 373                     me->me_type = strdup (typebuf);
 374             }
 375 #endif
 376             me->me_next = NULL;
 377
 378             /* Add to the linked list. */
 379             mtail->me_next = me;
 380             mtail = me;
 381         }
 382
 383         if (fclose (fp) == EOF)
 384             return NULL;
 385     }
 386 #endif /* MOUNTED_FREAD || MOUNTED_FREAD_FSTYP */
 387
 388 #ifdef MOUNTED_GETMNTTBL        /* DolphinOS goes it's own way */
 389     {
 390         struct mntent **mnttbl = getmnttbl (), **ent;
 391         for (ent = mnttbl; *ent; ent++) {
 392             me = (struct mount_entry *) malloc (sizeof (struct mount_entry));
 393             me->me_devname = strdup ((*ent)->mt_resource);
 394             me->me_mountdir = strdup ((*ent)->mt_directory);
 395             me->me_type = strdup ((*ent)->mt_fstype);
 396             me->me_dev = -1;    /* Magic; means not known yet. */
 397             me->me_next = NULL;
 398
 399             /* Add to the linked list. */
 400             mtail->me_next = me;
 401             mtail = me;
 402         }
 403         endmnttbl ();
 404     }
 405 #endif /* MOUNTED_GETMNTTBL */
 406
 407 #ifdef MOUNTED_GETMNTENT2       /* SVR4.  */
 408     {
 409         struct mnttab mnt;
 410         char *table = MNTTAB;
 411         FILE *fp;
 412         int ret;
 413
 414         fp = fopen (table, "r");
 415         if (fp == NULL)
 416             return NULL;
 417
 418         while ((ret = getmntent (fp, &mnt)) == 0) {
 419             me = (struct mount_entry *) malloc (sizeof (struct mount_entry));
 420             me->me_devname = strdup (mnt.mnt_special);
 421             me->me_mountdir = strdup (mnt.mnt_mountp);
 422             me->me_type = strdup (mnt.mnt_fstype);
 423             me->me_dev = -1;    /* Magic; means not known yet. */
 424             me->me_next = NULL;
 425             /* Add to the linked list. */
 426             mtail->me_next = me;
 427             mtail = me;
 428         }
 429
 430         if (ret > 0)
 431             return NULL;
 432         if (fclose (fp) == EOF)
 433             return NULL;
 434     }
 435 #endif /* MOUNTED_GETMNTENT2 */
 436
 437 #ifdef MOUNTED_VMOUNT           /* AIX.  */
 438     {
 439         int bufsize;
 440         char *entries, *thisent;
 441         struct vmount *vmp;
 442
 443         /* Ask how many bytes to allocate for the mounted filesystem info.  */
 444         mntctl (MCTL_QUERY, sizeof bufsize, (struct vmount *) &bufsize);
 445         entries = malloc (bufsize);
 446
 447         /* Get the list of mounted filesystems.  */
 448         mntctl (MCTL_QUERY, bufsize, (struct vmount *) entries);
 449
 450         for (thisent = entries; thisent < entries + bufsize;
 451              thisent += vmp->vmt_length) {
 452             vmp = (struct vmount *) thisent;
 453             me = (struct mount_entry *) malloc (sizeof (struct mount_entry));
 454             if (vmp->vmt_flags & MNT_REMOTE) {
 455                 char *host, *path;
 456
 457                 /* Prepend the remote pathname.  */
 458                 host = thisent + vmp->vmt_data[VMT_HOSTNAME].vmt_off;
 459                 path = thisent + vmp->vmt_data[VMT_OBJECT].vmt_off;
 460                 me->me_devname = malloc (strlen (host) + strlen (path) + 2);
 461                 strcpy (me->me_devname, host);
 462                 strcat (me->me_devname, ":");
 463                 strcat (me->me_devname, path);
 464             } else {
 465                 me->me_devname = strdup (thisent +
 466                                       vmp->vmt_data[VMT_OBJECT].vmt_off);
 467             }
 468             me->me_mountdir = strdup (thisent + vmp->vmt_data[VMT_STUB].vmt_off);
 469             me->me_type = strdup (fstype_to_string (vmp->vmt_gfstype));
 470             me->me_dev = -1;    /* vmt_fsid might be the info we want.  */
 471             me->me_next = NULL;
 472
 473             /* Add to the linked list. */
 474             mtail->me_next = me;
 475             mtail = me;
 476         }
 477         free (entries);
 478     }
 479 #endif /* MOUNTED_VMOUNT */
 480
 481     /* Free the dummy head. */
 482     me = mlist;
 483     mlist = mlist->me_next;
 484     free (me);
 485     return mlist;
 486 }
 487 #endif /* HAVE_INFOMOUNT_LIST */
 488
 489 #ifdef HAVE_INFOMOUNT_QNX
 490 /*
 491 ** QNX has no [gs]etmnt*(), [gs]etfs*(), or /etc/mnttab, but can do
 492 ** this via the following code.
 493 ** Note that, as this is based on CWD, it only fills one mount_entry
 494 ** structure. See my_statfs() in utilunix.c for the "other side" of
 495 ** this hack.
 496 */
 497
 498 static struct mount_entry *
 499 read_filesystem_list(int need_fs_type, int all_fs)
 500 {
 501         struct _disk_entry      de;
 502         struct statfs           fs;
 503         int                                     i, fd;
 504         char                            *tp, dev[_POSIX_NAME_MAX], dir[_POSIX_PATH_MAX];
 505
 506         static struct mount_entry       *me = NULL;
 507
 508         if (me)
 509         {
 510                 if (me->me_devname) free(me->me_devname);
 511                 if (me->me_mountdir) free(me->me_mountdir);
 512                 if (me->me_type) free(me->me_type);
 513         }
 514         else
 515                 me = (struct mount_entry *)malloc(sizeof(struct mount_entry));
 516
 517         if (!getcwd(dir, _POSIX_PATH_MAX)) return (NULL);
 518
 519         if ((fd = open(dir, O_RDONLY)) == -1) return (NULL);
 520
 521         i = disk_get_entry(fd, &de);
 522
 523         close(fd);
 524
 525         if (i == -1) return (NULL);
 526
 527         switch (de.disk_type)
 528         {
 529                 case _UNMOUNTED:        tp = "unmounted";       break;
 530                 case _FLOPPY:           tp = "Floppy";          break;
 531                 case _HARD:                     tp = "Hard";            break;
 532                 case _RAMDISK:          tp = "Ram";                     break;
 533                 case _REMOVABLE:        tp = "Removable";       break;
 534                 case _TAPE:                     tp = "Tape";            break;
 535                 case _CDROM:            tp = "CDROM";           break;
 536                 default:                        tp = "unknown";
 537         }
 538
 539         if (fsys_get_mount_dev(dir, &dev) == -1) return (NULL);
 540
 541         if (fsys_get_mount_pt(dev, &dir) == -1) return (NULL);
 542
 543         me->me_devname = strdup(dev);
 544         me->me_mountdir = strdup(dir);
 545         me->me_type = strdup(tp);
 546         me->me_dev = de.disk_type;
 547
 548 #ifdef DEBUG
 549         fprintf(stderr, "disk_get_entry():\n\tdisk_type=%d (%s)\n\tdriver_name='%-*.*s'\n\tdisk_drv=%d\n",
 550                 de.disk_type, tp, _DRIVER_NAME_LEN, _DRIVER_NAME_LEN, de.driver_name, de.disk_drv);
 551         fprintf(stderr, "fsys_get_mount_dev():\n\tdevice='%s'\n", dev);
 552         fprintf(stderr, "fsys_get_mount_pt():\n\tmount point='%s'\n", dir);
 553 #endif /* DEBUG */
 554
 555         return (me);
 556 }
 557 #endif /* HAVE_INFOMOUNT_QNX */
 558
 559 void
 560 init_my_statfs (void)
 561 {
 562 #ifdef HAVE_INFOMOUNT_LIST
 563     mount_list = read_filesystem_list (1, 1);
 564 #endif /* HAVE_INFOMOUNT_LIST */
 565 }
 566
 567 void
 568 my_statfs (struct my_statfs *myfs_stats, char *path)
 569 {
 570 #ifdef HAVE_INFOMOUNT_LIST
 571     int i, len = 0;
 572     struct mount_entry *entry = NULL;
 573     struct mount_entry *temp = mount_list;
 574     struct fs_usage fs_use;
 575
 576     while (temp){
 577         i = strlen (temp->me_mountdir);
 578         if (i > len && (strncmp (path, temp->me_mountdir, i) == 0))
 579             if (!entry || (path [i] == PATH_SEP || path [i] == 0)){
 580                 len = i;
 581                 entry = temp;
 582             }
 583         temp = temp->me_next;
 584     }
 585
 586     if (entry){
 587         get_fs_usage (entry->me_mountdir, &fs_use);
 588
 589         myfs_stats->type = entry->me_dev;
 590         myfs_stats->typename = entry->me_type;
 591         myfs_stats->mpoint = entry->me_mountdir;
 592         myfs_stats->device = entry->me_devname;
 593         myfs_stats->avail = getuid () ? fs_use.fsu_bavail/2 : fs_use.fsu_bfree/2;
 594         myfs_stats->total = fs_use.fsu_blocks/2;
 595         myfs_stats->nfree = fs_use.fsu_ffree;
 596         myfs_stats->nodes = fs_use.fsu_files;
 597     } else
 598 #endif /* HAVE_INFOMOUNT_LIST */
 599
 600 #ifdef HAVE_INFOMOUNT_QNX
 601 /*
 602 ** This is the "other side" of the hack to read_filesystem_list() in
 603 ** mountlist.c.
 604 ** It's not the most efficient approach, but consumes less memory. It
 605 ** also accomodates QNX's ability to mount filesystems on the fly.
 606 */
 607         struct mount_entry      *entry;
 608     struct fs_usage             fs_use;
 609
 610         if ((entry = read_filesystem_list(0, 0)) != NULL)
 611         {
 612                 get_fs_usage(entry->me_mountdir, &fs_use);
 613
 614                 myfs_stats->type = entry->me_dev;
 615                 myfs_stats->typename = entry->me_type;
 616                 myfs_stats->mpoint = entry->me_mountdir;
 617                 myfs_stats->device = entry->me_devname;
 618
 619                 myfs_stats->avail = fs_use.fsu_bfree / 2;
 620                 myfs_stats->total = fs_use.fsu_blocks / 2;
 621                 myfs_stats->nfree = fs_use.fsu_ffree;
 622                 myfs_stats->nodes = fs_use.fsu_files;
 623         }
 624         else
 625 #endif /* HAVE_INFOMOUNT_QNX */
 626     {
 627         myfs_stats->type = 0;
 628         myfs_stats->mpoint = "unknown";
 629         myfs_stats->device = "unknown";
 630         myfs_stats->avail = 0;
 631         myfs_stats->total = 0;
 632         myfs_stats->nfree = 0;
 633         myfs_stats->nodes = 0;
 634     }
 635 }
 636