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