src/proc_self_mountinfo.c

   1 #include "common.h"
   2
   3 // find the mount info with the given major:minor
   4 // in the supplied linked list of mountinfo structures
   5 struct mountinfo *mountinfo_find(struct mountinfo *root, unsigned long major, unsigned long minor) {
   6     struct mountinfo *mi;
   7
   8     for(mi = root; mi ; mi = mi->next)
   9         if(mi->major == major && mi->minor == minor)
  10             return mi;
  11
  12     return NULL;
  13 }
  14
  15 // find the mount info with the given filesystem and mount_source
  16 // in the supplied linked list of mountinfo structures
  17 struct mountinfo *mountinfo_find_by_filesystem_mount_source(struct mountinfo *root, const char *filesystem, const char *mount_source) {
  18     struct mountinfo *mi;
  19     uint32_t filesystem_hash = simple_hash(filesystem), mount_source_hash = simple_hash(mount_source);
  20
  21     for(mi = root; mi ; mi = mi->next)
  22         if(mi->filesystem
  23                 && mi->mount_source
  24                 && mi->filesystem_hash == filesystem_hash
  25                 && mi->mount_source_hash == mount_source_hash
  26                 && !strcmp(mi->filesystem, filesystem)
  27                 && !strcmp(mi->mount_source, mount_source))
  28             return mi;
  29
  30     return NULL;
  31 }
  32
  33 struct mountinfo *mountinfo_find_by_filesystem_super_option(struct mountinfo *root, const char *filesystem, const char *super_options) {
  34     struct mountinfo *mi;
  35     uint32_t filesystem_hash = simple_hash(filesystem);
  36
  37     size_t solen = strlen(super_options);
  38
  39     for(mi = root; mi ; mi = mi->next)
  40         if(mi->filesystem
  41                 && mi->super_options
  42                 && mi->filesystem_hash == filesystem_hash
  43                 && !strcmp(mi->filesystem, filesystem)) {
  44
  45             // super_options is a comma separated list
  46             char *s = mi->super_options, *e;
  47             while(*s) {
  48                 e = s + 1;
  49                 while(*e && *e != ',') e++;
  50
  51                 size_t len = e - s;
  52                 if(len == solen && !strncmp(s, super_options, len))
  53                     return mi;
  54
  55                 if(*e == ',') s = ++e;
  56                 else s = e;
  57             }
  58         }
  59
  60     return NULL;
  61 }
  62
  63
  64 // free a linked list of mountinfo structures
  65 void mountinfo_free(struct mountinfo *mi) {
  66     if(unlikely(!mi))
  67         return;
  68
  69     if(likely(mi->next))
  70         mountinfo_free(mi->next);
  71
  72     freez(mi->root);
  73     freez(mi->mount_point);
  74     freez(mi->mount_options);
  75
  76 /*
  77     if(mi->optional_fields_count) {
  78         int i;
  79         for(i = 0; i < mi->optional_fields_count ; i++)
  80             free(*mi->optional_fields[i]);
  81     }
  82     free(mi->optional_fields);
  83 */
  84     freez(mi->filesystem);
  85     freez(mi->mount_source);
  86     freez(mi->super_options);
  87     freez(mi);
  88 }
  89
  90 static char *strdupz_decoding_octal(const char *string) {
  91     char *buffer = strdupz(string);
  92
  93     char *d = buffer;
  94     const char *s = string;
  95
  96     while(*s) {
  97         if(unlikely(*s == '\\')) {
  98             s++;
  99             if(likely(isdigit(*s) && isdigit(s[1]) && isdigit(s[2]))) {
 100                 char c = *s++ - '0';
 101                 c <<= 3;
 102                 c |= *s++ - '0';
 103                 c <<= 3;
 104                 c |= *s++ - '0';
 105                 *d++ = c;
 106             }
 107             else *d++ = '_';
 108         }
 109         else *d++ = *s++;
 110     }
 111     *d = '\0';
 112
 113     return buffer;
 114 }
 115
 116 // read the whole mountinfo into a linked list
 117 struct mountinfo *mountinfo_read() {
 118     procfile *ff = NULL;
 119
 120     char filename[FILENAME_MAX + 1];
 121     snprintfz(filename, FILENAME_MAX, "%s/proc/self/mountinfo", global_host_prefix);
 122     ff = procfile_open(filename, " \t", PROCFILE_FLAG_DEFAULT);
 123     if(!ff) {
 124         snprintfz(filename, FILENAME_MAX, "%s/proc/1/mountinfo", global_host_prefix);
 125         ff = procfile_open(filename, " \t", PROCFILE_FLAG_DEFAULT);
 126         if(!ff) return NULL;
 127     }
 128
 129     ff = procfile_readall(ff);
 130     if(!ff) return NULL;
 131
 132     struct mountinfo *root = NULL, *last = NULL, *mi = NULL;
 133
 134     unsigned long l, lines = procfile_lines(ff);
 135     for(l = 0; l < lines ;l++) {
 136         if(procfile_linewords(ff, l) < 5)
 137             continue;
 138
 139         mi = mallocz(sizeof(struct mountinfo));
 140
 141         if(unlikely(!root))
 142             root = last = mi;
 143         else
 144             last->next = mi;
 145
 146         last = mi;
 147         mi->next = NULL;
 148
 149         unsigned long w = 0;
 150         mi->id = strtoul(procfile_lineword(ff, l, w), NULL, 10); w++;
 151         mi->parentid = strtoul(procfile_lineword(ff, l, w), NULL, 10); w++;
 152
 153         char *major = procfile_lineword(ff, l, w), *minor; w++;
 154         for(minor = major; *minor && *minor != ':' ;minor++) ;
 155         *minor = '\0';
 156         minor++;
 157
 158         mi->major = strtoul(major, NULL, 10);
 159         mi->minor = strtoul(minor, NULL, 10);
 160
 161         mi->root = strdupz(procfile_lineword(ff, l, w)); w++;
 162         mi->root_hash = simple_hash(mi->root);
 163
 164         mi->mount_point = strdupz_decoding_octal(procfile_lineword(ff, l, w)); w++;
 165         mi->mount_point_hash = simple_hash(mi->mount_point);
 166
 167         mi->mount_options = strdupz(procfile_lineword(ff, l, w)); w++;
 168
 169         // count the optional fields
 170 /*
 171         unsigned long wo = w;
 172 */
 173         mi->optional_fields_count = 0;
 174         char *s = procfile_lineword(ff, l, w);
 175         while(*s && *s != '-') {
 176             w++;
 177             s = procfile_lineword(ff, l, w);
 178             mi->optional_fields_count++;
 179         }
 180
 181 /*
 182         if(unlikely(mi->optional_fields_count)) {
 183             // we have some optional fields
 184             // read them into a new array of pointers;
 185
 186             mi->optional_fields = malloc(mi->optional_fields_count * sizeof(char *));
 187             if(unlikely(!mi->optional_fields))
 188                 fatal("Cannot allocate memory for %d mountinfo optional fields", mi->optional_fields_count);
 189
 190             int i;
 191             for(i = 0; i < mi->optional_fields_count ; i++) {
 192                 *mi->optional_fields[wo] = strdup(procfile_lineword(ff, l, w));
 193                 if(!mi->optional_fields[wo]) fatal("Cannot allocate memory");
 194                 wo++;
 195             }
 196         }
 197         else
 198             mi->optional_fields = NULL;
 199 */
 200
 201         if(likely(*s == '-')) {
 202             w++;
 203
 204             mi->filesystem = strdupz(procfile_lineword(ff, l, w)); w++;
 205             mi->filesystem_hash = simple_hash(mi->filesystem);
 206
 207             mi->mount_source = strdupz(procfile_lineword(ff, l, w)); w++;
 208             mi->mount_source_hash = simple_hash(mi->mount_source);
 209
 210             mi->super_options = strdupz(procfile_lineword(ff, l, w)); w++;
 211         }
 212         else {
 213             mi->filesystem = NULL;
 214             mi->mount_source = NULL;
 215             mi->super_options = NULL;
 216         }
 217
 218 /*
 219         info("MOUNTINFO: %u %u %u:%u root '%s', mount point '%s', mount options '%s', filesystem '%s', mount source '%s', super options '%s'",
 220              mi->id,
 221              mi->parentid,
 222              mi->major,
 223              mi->minor,
 224              mi->root,
 225              mi->mount_point,
 226              mi->mount_options,
 227              mi->filesystem,
 228              mi->mount_source,
 229              mi->super_options
 230         );
 231 */
 232     }
 233
 234     procfile_close(ff);
 235     return root;
 236 }