HAMMER Utilities: Sync to 58B
[dragonfly.git] / sbin / hammer / cmd_reblock.c
1 /*
2  * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  * 
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  * 
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  * 
34  * $DragonFly: src/sbin/hammer/cmd_reblock.c,v 1.8 2008/06/24 17:40:21 dillon Exp $
35  */
36
37 #include "hammer.h"
38
39 static void reblock_usage(int exit_code);
40
41 /*
42  * reblock <filesystem> [compaction_precentage] (default 90%)
43  */
44 void
45 hammer_cmd_reblock(char **av, int ac, int flags)
46 {
47         struct hammer_ioc_reblock reblock;
48         const char *filesystem;
49         int fd;
50         int perc;
51
52         bzero(&reblock, sizeof(reblock));
53
54         reblock.key_beg.localization = HAMMER_MIN_LOCALIZATION;
55         reblock.key_beg.obj_id = HAMMER_MIN_OBJID;
56         hammer_get_cycle(&reblock.key_beg.obj_id,
57                          &reblock.key_beg.localization);
58
59         reblock.key_end.localization = HAMMER_MAX_LOCALIZATION;
60         reblock.key_end.obj_id = HAMMER_MAX_OBJID;
61
62         reblock.head.flags = flags & HAMMER_IOC_DO_FLAGS;
63
64         /*
65          * Restrict the localization domain if asked to do inodes or data,
66          * but not both.
67          */
68         switch(flags & (HAMMER_IOC_DO_INODES|HAMMER_IOC_DO_DATA|HAMMER_IOC_DO_DIRS)) {
69         case HAMMER_IOC_DO_INODES:
70                 reblock.key_beg.localization = HAMMER_LOCALIZE_INODE;
71                 reblock.key_end.localization = HAMMER_LOCALIZE_INODE;
72                 break;
73         case HAMMER_IOC_DO_DIRS:
74         case HAMMER_IOC_DO_DATA:
75                 reblock.key_beg.localization = HAMMER_LOCALIZE_MISC;
76                 reblock.key_end.localization = HAMMER_LOCALIZE_MISC;
77                 break;
78         }
79
80         if (ac == 0)
81                 reblock_usage(1);
82         filesystem = av[0];
83         if (ac == 1) {
84                 perc = 100;
85         } else {
86                 perc = strtol(av[1], NULL, 0);
87                 if (perc < 0 || perc > 100)
88                         reblock_usage(1);
89         }
90         reblock.free_level = (int)((int64_t)perc *
91                                    HAMMER_LARGEBLOCK_SIZE / 100);
92         reblock.free_level = HAMMER_LARGEBLOCK_SIZE - reblock.free_level;
93         if (reblock.free_level < 0)
94                 reblock.free_level = 0;
95         printf("reblock free level %d\n", reblock.free_level);
96
97         fd = open(filesystem, O_RDONLY);
98         if (fd < 0)
99                 err(1, "Unable to open %s", filesystem);
100         if (ioctl(fd, HAMMERIOC_REBLOCK, &reblock) < 0) {
101                 printf("Reblock %s failed: %s\n", filesystem, strerror(errno));
102         } else if (reblock.head.flags & HAMMER_IOC_HEAD_INTR) {
103                 printf("Reblock %s interrupted by timer at %016llx %04x\n",
104                         filesystem,
105                         reblock.key_cur.obj_id,
106                         reblock.key_cur.localization);
107                 if (CyclePath) {
108                         hammer_set_cycle(reblock.key_cur.obj_id,
109                                          reblock.key_cur.localization);
110                 }
111         } else {
112                 if (CyclePath)
113                         hammer_reset_cycle();
114                 printf("Reblock %s succeeded\n", filesystem);
115         }
116         close(fd);
117         printf("Reblocked:\n"
118                "    %lld/%lld btree nodes\n"
119                "    %lld/%lld data elements\n"
120                "    %lld/%lld data bytes\n",
121                reblock.btree_moves, reblock.btree_count,
122                reblock.data_moves, reblock.data_count,
123                reblock.data_byte_moves, reblock.data_byte_count
124         );
125 }
126
127 static
128 void
129 reblock_usage(int exit_code)
130 {
131         fprintf(stderr, "hammer reblock <filesystem> [percentage]\n");
132         fprintf(stderr, "hammer reblock-btree <filesystem> [percentage]\n");
133         fprintf(stderr, "hammer reblock-inodes <filesystem> [percentage]\n");
134         fprintf(stderr, "hammer reblock-dirs <filesystem> [percentage]\n");
135         fprintf(stderr, "hammer reblock-data <filesystem> [percentage]\n");
136         fprintf(stderr, "By default 90%% is used.  Use 100%% to defragment\n");
137         exit(exit_code);
138 }
139