chiark / gitweb /
Add __oop-read-copy.c
[inn-innduct.git] / backends / inndf.c
1 /*  $Id: inndf.c 6677 2004-03-03 18:36:07Z hkehoe $
2 **
3 **  Reports free kilobytes (not disk blocks) or free inodes.
4 **
5 **  Written by Ian Dickinson <idickins@fore.com>
6 **  Wed Jul 26 10:11:38 BST 1995 (My birthday - 27 today!)
7 **
8 **  inndf is a replacement for 'df | awk' in innwatch.ctl and for reporting
9 **  free space in other INN scripts.  It doesn't sync, it forks less, and
10 **  it's generally less complicated.
11 **
12 **  Usage: inndf [-i] <directory> [<directory> ...]
13 **         inndf -n
14 **         inndf -o
15 **
16 **  Compile with -lserver (ie. /usr/lib/libserver.a) if you run Sun's Online
17 **  DiskSuite under SunOS 4.x.  The wrapper functions there make the system
18 **  call transparent; they copy the f_spare values to the correct spots, so
19 **  f_blocks, f_bfree, f_bavail can exceed 2GB.
20 **
21 **  Compile with -DHAVE_STATVFS for these systems:
22 **          System V Release 4.x
23 **          Solaris 2.x
24 **          HP-UX 10.x
25 **          OSF1
26 **  
27 **  Compile with -DHAVE_STATFS for these systems:
28 **          SunOS 4.x/Solaris 1.x
29 **          HP-UX 9.x
30 **          Linux
31 **          NeXTstep 3.x
32 **
33 **  (Or even better, let autoconf take care of it.)
34 **  
35 **  Thanks to these folks for bug fixes and porting information:
36 **          Mahesh Ramachandran <rr@eel.ufl.edu>
37 **          Chuck Swiger <chuck@its.com>
38 **          Sang-yong Suh <sysuh@kigam.re.kr>
39 **          Swa Frantzen <Swa.Frantzen@Belgium.EU.net>
40 **          Brad Dickey <bdickey@haverford.edu>
41 **          Taso N. Devetzis <devetzis@snet.net>
42 **          Wei-Yeh Lee <weiyeh@columbia.edu>
43 **          Jeff Garzik <jeff.garzik@spinne.com>
44 */
45
46 #include "config.h"
47 #include "clibrary.h"
48
49 #include "inn/innconf.h"
50 #include "inn/messages.h"
51 #include "inn/qio.h"
52 #include "libinn.h"
53 #include "ov.h"
54 #include "paths.h"
55
56 /* The portability mess.  Hide everything in macros so that the actual code
57    is relatively clean.  SysV uses statvfs, BSD uses statfs, and ULTRIX is
58    just weird (and isn't worth checking for in configure).
59
60    df_declare declares a variable of the appropriate type to pass to df_stat
61    along with a path; df_stat will return true on success, false on failure.
62    df_avail gives the number of free blocks, the size of those blocks given
63    in df_bsize (which handles SysV's weird fragment vs. preferred block size
64    thing).  df_inodes returns the free inodes. */
65 #if HAVE_STATVFS
66 # include <sys/statvfs.h>
67 # define df_stat(p, s)  (statvfs((p), (s)) == 0)
68 # define df_declare(s)  struct statvfs s
69 # define df_total(s)    ((s).f_blocks)
70 # define df_avail(s)    ((s).f_bavail)
71 # define df_scale(s)    ((s).f_frsize == 0 ? (s).f_bsize : (s).f_frsize)
72 # define df_files(s)    ((s).f_files)
73 # define df_favail(s)   ((s).f_favail)
74 #elif HAVE_STATFS
75 # if HAVE_SYS_VFS_H
76 #  include <sys/vfs.h>
77 # endif
78 # if HAVE_SYS_PARAM_H
79 #  include <sys/param.h>
80 # endif
81 # if HAVE_SYS_MOUNT_H
82 #  include <sys/mount.h>
83 # endif
84 # ifdef __ultrix__
85 #  define df_stat(p, s) (statfs((p), (s)) >= 1)
86 #  define df_declare(s) struct fs_data s
87 #  define df_total(s)   ((s).fd_btot)
88 #  define df_avail(s)   ((s).fd_bfreen)
89 #  define df_scale(s)   1024
90 #  define df_files(s)   ((s).fd_gtot)
91 #  define df_favail(s)  ((s).fd_gfree)
92 # else
93 #  define df_stat(p, s) (statfs((p), (s)) == 0)
94 #  define df_declare(s) struct statfs s
95 #  define df_total(s)   ((s).f_blocks)
96 #  define df_avail(s)   ((s).f_bavail)
97 #  define df_scale(s)   ((s).f_bsize)
98 #  define df_files(s)   ((s).f_files)
99 #  define df_favail(s)  ((s).f_ffree)
100 # endif
101 #else
102 # error "Platform not supported.  Neither statvfs nor statfs available."
103 #endif
104
105 static const char usage[] = "\
106 Usage: inndf [-i] [-f filename] [-F] <directory> [<directory> ...]\n\
107        inndf -n\n\
108        inndf -o\n\
109 \n\
110 The first form gives the free space in kilobytes (or the count of free\n\
111 inodes if -i is given) in the file systems given by the arguments.  If\n\
112 -f is given, the corresponding file should be a list of directories to\n\
113 check in addition to the arguments.  -F uses <pathetc>/filesystems as the\n\
114 file and is otherwise the same.\n\
115 \n\
116 The second form gives the total count of overview records stored.  The\n\
117 third form gives the percentage space allocated to overview that's been\n\
118 used (if the overview method used supports this query).";
119
120 /*
121 **  Given a path, a flag saying whether to look at inodes instead of free
122 **  disk space, and a flag saying whether to format in columns, print out
123 **  the amount of free space or inodes on that file system.  Returns the
124 **  percentage free, which may be printed out by the caller.
125 */
126 static void
127 printspace(const char *path, bool inode, bool fancy)
128 {
129     df_declare(info);
130     unsigned long amount;
131     double percent;
132
133     if (df_stat(path, &info)) {
134         if (inode) {
135             amount = df_favail(info);
136
137             /* This value is compared using the shell by innwatch, and some
138                shells can't cope with anything larger than the maximum value
139                of a signed long.  ReiserFS returns 2^32 - 1, however, since it
140                has no concept of inodes.  So cap the returned value at the max
141                value of a signed long. */
142             if (amount > (1UL << 31) - 1)
143                 amount = (1UL << 31) - 1;
144
145             /* 2.6 kernels show 0 available and used inodes, instead. */
146             if (amount == 0 && df_files(info) == 0)
147                 amount = (1UL << 31) - 1;
148         } else {
149             /* Do the multiplication in floating point to try to retain
150                accuracy if the free space in bytes would overflow an
151                unsigned long.  This should be safe until file systems larger
152                than 4TB (which may not be much longer -- we should use long
153                long instead if we have it).
154
155                Be very careful about the order of casts here; it's too
156                easy to cast back into an unsigned long a value that
157                overflows, and one then gets silently wrong results. */
158             amount = (unsigned long)
159                 (((double) df_avail(info) * df_scale(info)) / 1024.0);
160         }
161     } else {
162         /* On error, free space is zero. */
163         amount = 0;
164     }
165     printf(fancy ? "%10lu" : "%lu", amount);
166     if (fancy) {
167         printf(inode ? " inodes available " : " Kbytes available ");
168         if (inode)
169             percent = 100 * ((double) df_favail(info) / df_files(info));
170         else
171             percent = 100 * ((double) df_avail(info) / df_total(info));
172         if (percent < 9.95)
173             printf("  (%3.1f%%)", percent);
174         else if (percent < 99.95)
175             printf(" (%4.1f%%)", percent);
176         else
177             printf("(%5.1f%%)", percent);
178     }
179 }
180
181 static void
182 printspace_formatted(const char *path, bool inode)
183 {
184     printf("%-40s ", path);
185     printspace(path, inode, true);
186     printf("\n");
187 }
188
189 static char *
190 readline(QIOSTATE *qp)
191 {
192     char *line, *p;
193
194     for (line = QIOread(qp); line != NULL; line = QIOread(qp)) {
195         p = strchr(line, '#');
196         if (p != NULL)
197             *p = '\0';
198         for (; *line == ' ' || *line == '\t'; line++)
199             ;
200         if (*line != '\0') {
201             for (p = line; *p != '\0' && *p != ' ' && *p != '\t'; p++)
202                 ;
203             *p = '\0';
204             return line;
205         }
206     }
207     return NULL;
208 }
209
210 int
211 main(int argc, char *argv[])
212 {
213     int option, i, count;
214     unsigned long total;
215     QIOSTATE *qp;
216     char *active, *group, *line, *p;
217     char *file = NULL;
218     bool inode = false;
219     bool overview = false;
220     bool ovcount = false;
221     bool use_filesystems = false;
222
223     while ((option = getopt(argc, argv, "hinof:F")) != EOF) {
224         switch (option) {
225         default:
226             die(usage);
227         case 'h':
228             printf("%s\n", usage);
229             exit(0);
230         case 'i':
231             inode = true;
232             break;
233         case 'n':
234             ovcount = true;
235             break;
236         case 'o':
237             overview = true;
238             break;
239         case 'f':
240             if (file != NULL)
241                 die("inndf: Only one of -f or -F may be given");
242             file = xstrdup(optarg);
243             break;
244         case 'F':
245             if (file != NULL)
246                 die("inndf: Only one of -f or -F may be given");
247             if (!innconf_read(NULL))
248                 exit(1);
249             file = concatpath(innconf->pathetc, INN_PATH_FILESYSTEMS);
250             use_filesystems = true;
251             break;
252         }
253     }
254     argc -= optind;
255     argv += optind;
256
257     if (argc == 0 && !overview && !ovcount && file == NULL)
258         die(usage);
259
260     /* Set the program name now rather than earlier so that it doesn't get
261        prepended to usage messages. */
262     message_program_name = "inndf";
263
264     /* If directories were specified, get statistics about them.  If only
265        one was given, just print out the number without the path or any
266        explanatory text; this mode is used by e.g. innwatch.  Otherwise,
267        format things nicely. */
268     if (argc == 1 && !overview && !ovcount && file == NULL) {
269         printspace(argv[0], inode, false);
270         printf("\n");
271     } else {
272         for (i = 0; i < argc; i++)
273             printspace_formatted(argv[i], inode);
274         if (file != NULL) {
275             qp = QIOopen(file);
276             if (qp == NULL) {
277                 if (!use_filesystems)
278                     sysdie("can't open %s", file);
279             } else {
280                 line = readline(qp);
281                 while (line != NULL) {
282                     printspace_formatted(line, inode);
283                     line = readline(qp);
284                 }
285                 QIOclose(qp);
286             }
287             free(file);
288         }
289     }
290
291     /* If we're going to be getting information from overview, do the icky
292        initialization stuff. */
293     if (overview || ovcount) {
294         if (!use_filesystems)
295             if (!innconf_read(NULL))
296                 exit(1);
297         if (!OVopen(OV_READ))
298             die("OVopen failed");
299     }
300
301     /* For the count, we have to troll through the active file and query the
302        overview backend for each group. */
303     if (ovcount) {
304         active = concatpath(innconf->pathdb, _PATH_ACTIVE);
305         qp = QIOopen(active);
306         if (qp == NULL)
307             sysdie("can't open %s", active);
308
309         total = 0;
310         group = QIOread(qp);
311         while (group != NULL) {
312             p = strchr(group, ' ');
313             if (p != NULL)
314                 *p = '\0';
315             if (OVgroupstats(group, NULL, NULL, &count, NULL))
316                 total += count;
317             group = QIOread(qp);
318         }
319         QIOclose(qp);
320         printf("%lu overview records stored\n", total);
321     }
322
323     /* Percentage used is simpler, but only some overview methods understand
324        that query. */
325     if (overview) {
326         if (OVctl(OVSPACE, &count)) {
327             if (count == -1)
328                 printf("Space used is meaningless for the %s method\n",
329                        innconf->ovmethod);
330             else
331                 printf("%d%% overview space used\n", count);
332         }
333     }
334     exit(0);
335 }