vcs.maemo.org Git - monky/blob - src/fs.c

   1 /* -*- mode: c; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: t -*-
   2  *
   3  * Conky, a system monitor, based on torsmo
   4  *
   5  * Any original torsmo code is licensed under the BSD license
   6  *
   7  * All code written since the fork of torsmo is licensed under the GPL
   8  *
   9  * Please see COPYING for details
  10  *
  11  * Copyright (c) 2004, Hannu Saransaari and Lauri Hakkarainen
  12  * Copyright (c) 2005-2009 Brenden Matthews, Philip Kovacs, et. al.
  13  *      (see AUTHORS)
  14  * All rights reserved.
  15  *
  16  * This program is free software: you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation, either version 3 of the License, or
  19  * (at your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  27  *
  28  * vim: ts=4 sw=4 noet ai cindent syntax=c
  29  *
  30  */
  31
  32 #include "conky.h"
  33 #include "logging.h"
  34 #include "fs.h"
  35 #include <unistd.h>
  36 #include <errno.h>
  37 #include <sys/types.h>
  38 #include <fcntl.h>
  39
  40 /* linux */
  41 #ifdef HAVE_SYS_STATFS_H
  42 #include <sys/statfs.h>
  43 #endif
  44
  45 /* freebsd && netbsd */
  46 #ifdef HAVE_SYS_PARAM_H
  47 #include <sys/param.h>
  48 #endif
  49 #ifdef HAVE_SYS_MOUNT_H
  50 #include <sys/mount.h>
  51 #endif
  52
  53 #if !defined(HAVE_STRUCT_STATFS_F_FSTYPENAME) && !defined (__OpenBSD__) && !defined(__FreeBSD__)
  54 #include <mntent.h>
  55 #endif
  56
  57 #define MAX_FS_STATS 64
  58
  59 static struct fs_stat fs_stats_[MAX_FS_STATS];
  60 struct fs_stat *fs_stats = fs_stats_;
  61
  62 static void update_fs_stat(struct fs_stat *fs);
  63
  64 void get_fs_type(const char *path, char *result);
  65
  66 void update_fs_stats(void)
  67 {
  68         unsigned i;
  69
  70         for (i = 0; i < MAX_FS_STATS; ++i) {
  71                 if (fs_stats[i].set) {
  72                         update_fs_stat(&fs_stats[i]);
  73                 }
  74         }
  75 }
  76
  77 void clear_fs_stats(void)
  78 {
  79         unsigned i;
  80         for (i = 0; i < MAX_FS_STATS; ++i) {
  81                 memset(&fs_stats[i], 0, sizeof(struct fs_stat));
  82         }
  83 }
  84
  85 struct fs_stat *prepare_fs_stat(const char *s)
  86 {
  87         struct fs_stat *new = 0;
  88         unsigned i;
  89
  90         /* lookup existing or get new */
  91         for (i = 0; i < MAX_FS_STATS; ++i) {
  92                 if (fs_stats[i].set) {
  93                         if (strncmp(fs_stats[i].path, s, DEFAULT_TEXT_BUFFER_SIZE) == 0) {
  94                                 return &fs_stats[i];
  95                         }
  96                 } else {
  97                         new = &fs_stats[i];
  98                 }
  99         }
 100         /* new path */
 101         if (!new) {
 102                 ERR("too many fs stats");
 103                 return 0;
 104         }
 105         strncpy(new->path, s, DEFAULT_TEXT_BUFFER_SIZE);
 106         new->set = 1;
 107         update_fs_stat(new);
 108         return new;
 109 }
 110
 111 static void update_fs_stat(struct fs_stat *fs)
 112 {
 113         struct statfs s;
 114
 115         if (statfs(fs->path, &s) == 0) {
 116                 fs->size = (long long)s.f_blocks * s.f_bsize;
 117                 /* bfree (root) or bavail (non-roots) ? */
 118                 fs->avail = (long long)s.f_bavail * s.f_bsize;
 119                 fs->free = (long long)s.f_bfree * s.f_bsize;
 120                 get_fs_type(fs->path, fs->type);
 121         } else {
 122                 fs->size = 0;
 123                 fs->avail = 0;
 124                 fs->free = 0;
 125                 strncpy(fs->type, "unknown", DEFAULT_TEXT_BUFFER_SIZE);
 126                 ERR("statfs '%s': %s", fs->path, strerror(errno));
 127         }
 128 }
 129
 130 void get_fs_type(const char *path, char *result)
 131 {
 132
 133 #if defined(HAVE_STRUCT_STATFS_F_FSTYPENAME) || defined(__FreeBSD__) || defined (__OpenBSD__)
 134
 135         struct statfs s;
 136         if (statfs(path, &s) == 0) {
 137                 strncpy(result, s.f_fstypename, DEFAULT_TEXT_BUFFER_SIZE);
 138         } else {
 139                 ERR("statfs '%s': %s", path, strerror(errno));
 140         }
 141         return;
 142
 143 #else                           /* HAVE_STRUCT_STATFS_F_FSTYPENAME */
 144
 145         struct mntent *me;
 146         FILE *mtab = setmntent("/etc/mtab", "r");
 147         char *search_path;
 148         int match;
 149         char *slash;
 150
 151         if (mtab == NULL) {
 152                 ERR("setmntent /etc/mtab: %s", strerror(errno));
 153                 strncpy(result, "unknown", DEFAULT_TEXT_BUFFER_SIZE);
 154                 return;
 155         }
 156
 157         me = getmntent(mtab);
 158
 159         // find our path in the mtab
 160         search_path = strdup(path);
 161         do {
 162                 while ((match = strcmp(search_path, me->mnt_dir))
 163                                 && getmntent(mtab));
 164                 if (!match)
 165                         break;
 166                 fseek(mtab, 0, SEEK_SET);
 167                 slash = strrchr(search_path, '/');
 168                 if (slash == NULL)
 169                         CRIT_ERR(NULL, NULL, "invalid path '%s'", path);
 170                 if (strlen(slash) == 1)         /* trailing slash */
 171                         *(slash) = '\0';
 172                 else if (strlen(slash) > 1)
 173                         *(slash + 1) = '\0';
 174                 else
 175                         CRIT_ERR(NULL, NULL, "found a crack in the matrix!");
 176         } while (strlen(search_path) > 0);
 177         free(search_path);
 178
 179         endmntent(mtab);
 180
 181         if (me && !match) {
 182                 strncpy(result, me->mnt_type, DEFAULT_TEXT_BUFFER_SIZE);
 183                 return;
 184         }
 185 #endif                          /* HAVE_STRUCT_STATFS_F_FSTYPENAME */
 186
 187         strncpy(result, "unknown", DEFAULT_TEXT_BUFFER_SIZE);
 188
 189 }