1 /* $NetBSD: archive.c,v 1.1.1.3 2009/12/02 00:26:28 haad Exp $ */
2
3 /*
4 * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
5 * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
6 *
7 * This file is part of LVM2.
8 *
9 * This copyrighted material is made available to anyone wishing to use,
10 * modify, copy, or redistribute it subject to the terms and conditions
11 * of the GNU Lesser General Public License v.2.1.
12 *
13 * You should have received a copy of the GNU Lesser General Public License
14 * along with this program; if not, write to the Free Software Foundation,
15 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 */
17
18 #include "lib.h"
19 #include "format-text.h"
20
21 #include "config.h"
22 #include "import-export.h"
23 #include "lvm-string.h"
24 #include "lvm-file.h"
25 #include "toolcontext.h"
26
27 #include <dirent.h>
28 #include <unistd.h>
29 #include <sys/stat.h>
30 #include <sys/file.h>
31 #include <fcntl.h>
32 #include <time.h>
33
34 #define SECS_PER_DAY 86400 /* 24*60*60 */
35
36 /*
37 * The format instance is given a directory path upon creation.
38 * Each file in this directory whose name is of the form
39 * '(.*)_[0-9]*.vg' is a config file (see lib/config.[hc]), which
40 * contains a description of a single volume group.
41 *
42 * The prefix ($1 from the above regex) of the config file gives
43 * the volume group name.
44 *
45 * Backup files that have expired will be removed.
46 */
47
48 /*
49 * A list of these is built up for our volume group. Ordered
50 * with the least recent at the head.
51 */
52 struct archive_file {
53 struct dm_list list;
54
55 char *path;
56 uint32_t index;
57 };
58
59 /*
60 * Extract vg name and version number from a filename.
61 */
_split_vg(const char * filename,char * vgname,size_t vgsize,uint32_t * ix)62 static int _split_vg(const char *filename, char *vgname, size_t vgsize,
63 uint32_t *ix)
64 {
65 size_t len, vg_len;
66 const char *dot, *underscore;
67
68 len = strlen(filename);
69 if (len < 7)
70 return 0;
71
72 dot = (filename + len - 3);
73 if (strcmp(".vg", dot))
74 return 0;
75
76 if (!(underscore = strrchr(filename, '_')))
77 return 0;
78
79 if (sscanf(underscore + 1, "%u", ix) != 1)
80 return 0;
81
82 vg_len = underscore - filename;
83 if (vg_len + 1 > vgsize)
84 return 0;
85
86 strncpy(vgname, filename, vg_len);
87 vgname[vg_len] = '\0';
88
89 return 1;
90 }
91
_insert_archive_file(struct dm_list * head,struct archive_file * b)92 static void _insert_archive_file(struct dm_list *head, struct archive_file *b)
93 {
94 struct archive_file *bf = NULL;
95
96 if (dm_list_empty(head)) {
97 dm_list_add(head, &b->list);
98 return;
99 }
100
101 /* index reduces through list */
102 dm_list_iterate_items(bf, head) {
103 if (b->index > bf->index) {
104 dm_list_add(&bf->list, &b->list);
105 return;
106 }
107 }
108
109 dm_list_add_h(&bf->list, &b->list);
110 }
111
_join_file_to_dir(struct dm_pool * mem,const char * dir,const char * name)112 static char *_join_file_to_dir(struct dm_pool *mem, const char *dir, const char *name)
113 {
114 if (!dm_pool_begin_object(mem, 32) ||
115 !dm_pool_grow_object(mem, dir, strlen(dir)) ||
116 !dm_pool_grow_object(mem, "/", 1) ||
117 !dm_pool_grow_object(mem, name, strlen(name)) ||
118 !dm_pool_grow_object(mem, "\0", 1))
119 return_NULL;
120
121 return dm_pool_end_object(mem);
122 }
123
124 /*
125 * Returns a list of archive_files.
126 */
_scan_archive(struct dm_pool * mem,const char * vgname,const char * dir)127 static struct dm_list *_scan_archive(struct dm_pool *mem,
128 const char *vgname, const char *dir)
129 {
130 int i, count;
131 uint32_t ix;
132 char vgname_found[64], *path;
133 struct dirent **dirent;
134 struct archive_file *af;
135 struct dm_list *results;
136
137 if (!(results = dm_pool_alloc(mem, sizeof(*results))))
138 return_NULL;
139
140 dm_list_init(results);
141
142 /* Sort fails beyond 5-digit indexes */
143 if ((count = scandir(dir, &dirent, NULL, alphasort)) < 0) {
144 log_error("Couldn't scan the archive directory (%s).", dir);
145 return 0;
146 }
147
148 for (i = 0; i < count; i++) {
149 if (!strcmp(dirent[i]->d_name, ".") ||
150 !strcmp(dirent[i]->d_name, ".."))
151 continue;
152
153 /* check the name is the correct format */
154 if (!_split_vg(dirent[i]->d_name, vgname_found,
155 sizeof(vgname_found), &ix))
156 continue;
157
158 /* is it the vg we're interested in ? */
159 if (strcmp(vgname, vgname_found))
160 continue;
161
162 if (!(path = _join_file_to_dir(mem, dir, dirent[i]->d_name)))
163 goto_out;
164
165 /*
166 * Create a new archive_file.
167 */
168 if (!(af = dm_pool_alloc(mem, sizeof(*af)))) {
169 log_error("Couldn't create new archive file.");
170 results = NULL;
171 goto out;
172 }
173
174 af->index = ix;
175 af->path = path;
176
177 /*
178 * Insert it to the correct part of the list.
179 */
180 _insert_archive_file(results, af);
181 }
182
183 out:
184 for (i = 0; i < count; i++)
185 free(dirent[i]);
186 free(dirent);
187
188 return results;
189 }
190
_remove_expired(struct dm_list * archives,uint32_t archives_size,uint32_t retain_days,uint32_t min_archive)191 static void _remove_expired(struct dm_list *archives, uint32_t archives_size,
192 uint32_t retain_days, uint32_t min_archive)
193 {
194 struct archive_file *bf;
195 struct stat sb;
196 time_t retain_time;
197
198 /* Make sure there are enough archives to even bother looking for
199 * expired ones... */
200 if (archives_size <= min_archive)
201 return;
202
203 /* Convert retain_days into the time after which we must retain */
204 retain_time = time(NULL) - (time_t) retain_days *SECS_PER_DAY;
205
206 /* Assume list is ordered newest first (by index) */
207 dm_list_iterate_back_items(bf, archives) {
208 /* Get the mtime of the file and unlink if too old */
209 if (stat(bf->path, &sb)) {
210 log_sys_error("stat", bf->path);
211 continue;
212 }
213
214 if (sb.st_mtime > retain_time)
215 return;
216
217 log_very_verbose("Expiring archive %s", bf->path);
218 if (unlink(bf->path))
219 log_sys_error("unlink", bf->path);
220
221 /* Don't delete any more if we've reached the minimum */
222 if (--archives_size <= min_archive)
223 return;
224 }
225 }
226
archive_vg(struct volume_group * vg,const char * dir,const char * desc,uint32_t retain_days,uint32_t min_archive)227 int archive_vg(struct volume_group *vg,
228 const char *dir, const char *desc,
229 uint32_t retain_days, uint32_t min_archive)
230 {
231 int i, fd, renamed = 0;
232 uint32_t ix = 0;
233 struct archive_file *last;
234 FILE *fp = NULL;
235 char temp_file[PATH_MAX], archive_name[PATH_MAX];
236 struct dm_list *archives;
237
238 /*
239 * Write the vg out to a temporary file.
240 */
241 if (!create_temp_name(dir, temp_file, sizeof(temp_file), &fd,
242 &vg->cmd->rand_seed)) {
243 log_error("Couldn't create temporary archive name.");
244 return 0;
245 }
246
247 if (!(fp = fdopen(fd, "w"))) {
248 log_error("Couldn't create FILE object for archive.");
249 if (close(fd))
250 log_sys_error("close", temp_file);
251 return 0;
252 }
253
254 if (!text_vg_export_file(vg, desc, fp)) {
255 if (fclose(fp))
256 log_sys_error("fclose", temp_file);
257 return_0;
258 }
259
260 if (lvm_fclose(fp, temp_file))
261 return_0; /* Leave file behind as evidence of failure */
262
263 /*
264 * Now we want to rename this file to <vg>_index.vg.
265 */
266 if (!(archives = _scan_archive(vg->cmd->mem, vg->name, dir)))
267 return_0;
268
269 if (dm_list_empty(archives))
270 ix = 0;
271 else {
272 last = dm_list_item(dm_list_first(archives), struct archive_file);
273 ix = last->index + 1;
274 }
275
276 for (i = 0; i < 10; i++) {
277 if (dm_snprintf(archive_name, sizeof(archive_name),
278 "%s/%s_%05u.vg", dir, vg->name, ix) < 0) {
279 log_error("Archive file name too long.");
280 return 0;
281 }
282
283 if ((renamed = lvm_rename(temp_file, archive_name)))
284 break;
285
286 ix++;
287 }
288
289 if (!renamed)
290 log_error("Archive rename failed for %s", temp_file);
291
292 _remove_expired(archives, dm_list_size(archives) + renamed, retain_days,
293 min_archive);
294
295 return 1;
296 }
297
_display_archive(struct cmd_context * cmd,struct archive_file * af)298 static void _display_archive(struct cmd_context *cmd, struct archive_file *af)
299 {
300 struct volume_group *vg = NULL;
301 struct format_instance *tf;
302 time_t when;
303 char *desc;
304 void *context;
305
306 log_print(" ");
307 log_print("File:\t\t%s", af->path);
308
309 if (!(context = create_text_context(cmd, af->path, NULL)) ||
310 !(tf = cmd->fmt_backup->ops->create_instance(cmd->fmt_backup, NULL,
311 NULL, context))) {
312 log_error("Couldn't create text instance object.");
313 return;
314 }
315
316 /*
317 * Read the archive file to ensure that it is valid, and
318 * retrieve the archive time and description.
319 */
320 /* FIXME Use variation on _vg_read */
321 if (!(vg = text_vg_import_file(tf, af->path, &when, &desc))) {
322 log_print("Unable to read archive file.");
323 tf->fmt->ops->destroy_instance(tf);
324 return;
325 }
326
327 log_print("VG name: \t%s", vg->name);
328 log_print("Description:\t%s", desc ? : "<No description>");
329 log_print("Backup Time:\t%s", ctime(&when));
330
331 vg_release(vg);
332 tf->fmt->ops->destroy_instance(tf);
333 }
334
archive_list(struct cmd_context * cmd,const char * dir,const char * vgname)335 int archive_list(struct cmd_context *cmd, const char *dir, const char *vgname)
336 {
337 struct dm_list *archives;
338 struct archive_file *af;
339
340 if (!(archives = _scan_archive(cmd->mem, vgname, dir)))
341 return_0;
342
343 if (dm_list_empty(archives))
344 log_print("No archives found in %s.", dir);
345
346 dm_list_iterate_back_items(af, archives)
347 _display_archive(cmd, af);
348
349 dm_pool_free(cmd->mem, archives);
350
351 return 1;
352 }
353
archive_list_file(struct cmd_context * cmd,const char * file)354 int archive_list_file(struct cmd_context *cmd, const char *file)
355 {
356 struct archive_file af;
357
358 af.path = (char *)file;
359
360 if (!path_exists(af.path)) {
361 log_error("Archive file %s not found.", af.path);
362 return 0;
363 }
364
365 _display_archive(cmd, &af);
366
367 return 1;
368 }
369
backup_list(struct cmd_context * cmd,const char * dir,const char * vgname)370 int backup_list(struct cmd_context *cmd, const char *dir, const char *vgname)
371 {
372 struct archive_file af;
373
374 if (!(af.path = _join_file_to_dir(cmd->mem, dir, vgname)))
375 return_0;
376
377 if (path_exists(af.path))
378 _display_archive(cmd, &af);
379
380 return 1;
381 }
382