lib/libc/gen/getvfsent.c

   1 /*
   2  * getvfsent.c - get a listing of installed filesystems
   3  * Written September 1994 by Garrett A. Wollman
   4  * This file is in the public domain.
   5  *
   6  * $FreeBSD: src/lib/libc/gen/getvfsent.c,v 1.14.2.1 2001/03/05 09:19:38 obrien Exp $
   7  * $DragonFly: src/lib/libc/gen/getvfsent.c,v 1.2 2003/06/17 04:26:42 dillon Exp $
   8  */
   9
  10 #include <sys/param.h>
  11 #include <sys/types.h>
  12 #include <sys/mount.h>
  13 #include <sys/sysctl.h>
  14 #include <unistd.h>
  15 #include <sys/file.h>
  16 #include <sys/wait.h>
  17 #include <string.h>
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include <paths.h>
  21
  22 /* XXX hide some compatibility problems. */
  23 #undef getvfsbyname
  24 #define vfsconf         ovfsconf
  25
  26 static struct vfsconf *_vfslist = 0;
  27 static struct vfsconf _vfsconf;
  28 static size_t _vfslistlen = 0;
  29 static int _vfs_keeplist = 0;
  30 static int _vfs_index = 0;
  31
  32 static int
  33 initvfs(void)
  34 {
  35         int mib[2] = { CTL_VFS, VFS_VFSCONF };
  36         size_t size = 0;
  37         int rv;
  38
  39         rv = sysctl(mib, 2, (void *)0, &size, (void *)0, (size_t)0);
  40         if(rv < 0)
  41                 return 0;
  42
  43         if(_vfslist)
  44                 free(_vfslist);
  45         _vfslist = malloc(size);
  46         if(!_vfslist)
  47                 return 0;
  48
  49         rv = sysctl(mib, 2, _vfslist, &size, (void *)0, (size_t)0);
  50         if(rv < 0) {
  51                 free(_vfslist);
  52                 _vfslist = 0;
  53                 return 0;
  54         }
  55
  56         _vfslistlen = size / sizeof _vfslist[0];
  57         return 1;
  58 }
  59
  60 struct vfsconf *
  61 getvfsent(void)
  62 {
  63         if(!_vfslist && !initvfs()) {
  64                 return 0;
  65         }
  66
  67         do {
  68                 if(_vfs_index >= _vfslistlen) {
  69                         return 0;
  70                 }
  71
  72                 _vfsconf = _vfslist[_vfs_index++];
  73         } while(!_vfsconf.vfc_vfsops);
  74
  75         if(!_vfs_keeplist) {
  76                 free(_vfslist);
  77                 _vfslist = 0;
  78         }
  79         return &_vfsconf;
  80 }
  81
  82 struct vfsconf *
  83 getvfsbyname(const char *name)
  84 {
  85         int i;
  86
  87         if(!_vfslist && !initvfs()) {
  88                 return 0;
  89         }
  90
  91         for(i = 0; i < _vfslistlen; i++) {
  92                 if( ! strcmp(_vfslist[i].vfc_name, name) )
  93                         break;
  94         }
  95
  96         if(i < _vfslistlen) {
  97                 _vfsconf = _vfslist[i];
  98         }
  99
 100         if(!_vfs_keeplist) {
 101                 free(_vfslist);
 102                 _vfslist = 0;
 103         }
 104
 105         if(i < _vfslistlen) {
 106                 return &_vfsconf;
 107         } else {
 108                 return 0;
 109         }
 110 }
 111
 112 struct vfsconf *
 113 getvfsbytype(int type)
 114 {
 115         int i;
 116
 117         if(!_vfslist && !initvfs()) {
 118                 return 0;
 119         }
 120
 121         for(i = 0; i < _vfslistlen; i++) {
 122                 if(_vfslist[i].vfc_index == type)
 123                         break;
 124         }
 125
 126         if(i < _vfslistlen) {
 127                 _vfsconf = _vfslist[i];
 128         }
 129
 130         if(!_vfs_keeplist) {
 131                 free(_vfslist);
 132                 _vfslist = 0;
 133         }
 134
 135         if(i < _vfslistlen) {
 136                 return &_vfsconf;
 137         } else {
 138                 return 0;
 139         }
 140 }
 141
 142 void
 143 setvfsent(int keep)
 144 {
 145         if(_vfslist && !keep) {
 146                 free(_vfslist);
 147                 _vfslist = 0;
 148         }
 149
 150         _vfs_keeplist = keep;
 151         _vfs_index = 0;
 152 }
 153
 154 void
 155 endvfsent(void)
 156 {
 157         if(_vfslist) {
 158                 free(_vfslist);
 159                 _vfslist = 0;
 160         }
 161
 162         _vfs_index = 0;
 163 }
 164
 165 int
 166 vfsisloadable(const char *name)
 167 {
 168         return 1;
 169 }
 170
 171 int
 172 vfsload(const char *name)
 173 {
 174         int status;
 175
 176         status = kldload(name);
 177         return status == -1 ? status : 0;
 178 }
 179