xref: /illumos-gate/usr/src/cmd/backup/dump/dumpitime.c (revision e0dfa398a76c38cdf3380b38117ee2d1ed3249f0)
1 /*
2  * Copyright 1996-1998, 2002-2003 Sun Microsystems, Inc.  All rights reserved.
3  * Use is subject to license terms.
4  */
5 
6 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
7 /*	  All Rights Reserved	*/
8 
9 /*
10  * Copyright (c) 1980 Regents of the University of California.
11  * All rights reserved.  The Berkeley software License Agreement
12  * specifies the terms and conditions for redistribution.
13  */
14 
15 #include "dump.h"
16 
17 #ifndef LOCK_EX
18 static	struct flock fl;
19 #define	flock(fd, flag) (fl.l_type = (flag), fcntl(fd, F_SETLKW, &fl))
20 #define	LOCK_EX F_WRLCK
21 #define	LOCK_SH F_RDLCK
22 #define	LOCK_UN F_UNLCK
23 #endif
24 
25 char		*disk;
26 char		*dname;
27 char		*increm;
28 
29 char		incno;
30 char		lastincno;
31 int		uflag;
32 uint_t		msiz;
33 u_offset_t	o_esize;
34 u_offset_t	f_esize;
35 
36 /*
37  * Print a date.  A date of 0 is the beginning of time (the "epoch").
38  * If the 2nd argument is non-zero, it is ok to format the date in
39  * locale-specific form, otherwise we use ctime.  We must use ctime
40  * for dates such as those in the dumpdates file, which must be
41  * locale-independent.
42  */
43 char *
prdate(time_t d)44 prdate(time_t d)
45 {
46 	static char buf[256];
47 	struct tm *tm;
48 	char *p;
49 
50 	if (d == 0)
51 		return (gettext("the epoch"));
52 
53 	tm = localtime(&d);
54 	if (strftime(buf, sizeof (buf), "%c", tm) != 0) {
55 		p = buf;
56 	} else {
57 		/* Wouldn't fit in buf, fall back */
58 		p = ctime(&d);
59 		p[24] = '\0';	/* lose trailing newline */
60 	}
61 	return (p);
62 }
63 
64 struct	idates	**idatev = 0;
65 size_t	nidates = 0;
66 static	int	idates_in = 0;		/* we have read the increment file */
67 static	int	recno;
68 
69 #ifdef __STDC__
70 static void readitimes(FILE *);
71 static void recout(FILE	*, struct idates *);
72 static int getrecord(FILE *, struct idates *);
73 static int makeidate(struct idates *, char *);
74 #else
75 static void readitimes();
76 static void recout();
77 static int getrecord();
78 static int makeidate();
79 #endif
80 
81 void
inititimes(void)82 inititimes(void)
83 {
84 	FILE *df;
85 	int saverr;
86 
87 	if (idates_in)
88 		return;
89 	if (increm == NULL || *increm == '\0') {
90 		msg(gettext("inititimes: No dump record file name defined\n"));
91 		dumpabort();
92 		/*NOTREACHED*/
93 	}
94 	/*
95 	 * No need to secure this, as increm is hard-coded to NINCREM,
96 	 * and that file is in /etc.  If random people have write-permission
97 	 * there, then there are more problems than any degree of paranoia
98 	 * on our part can fix.
99 	 */
100 	if ((df = fopen(increm, "r")) == NULL) {
101 		saverr = errno;
102 		if (errno == ENOENT)
103 			msg(gettext(
104 			    "Warning - dump record file `%s' does not exist\n"),
105 			    increm);
106 		else {
107 			msg(gettext("Cannot open dump record file `%s': %s\n"),
108 			    increm, strerror(saverr));
109 			dumpabort();
110 			/*NOTREACHED*/
111 		}
112 		return;
113 	}
114 	if (uflag && access(increm, W_OK) < 0) {
115 		msg(gettext("Cannot access dump record file `%s' for update\n"),
116 		    increm);
117 		dumpabort();
118 		/*NOTREACHED*/
119 	}
120 	(void) flock(fileno(df), LOCK_SH);
121 	readitimes(df);
122 	(void) fclose(df);
123 }
124 
125 static void
readitimes(FILE * df)126 readitimes(FILE *df)
127 {
128 	struct idates *idp;
129 
130 	recno = 0;
131 	for (;;) {
132 		idp = (struct idates *)xcalloc(1, sizeof (*idp));
133 		if (getrecord(df, idp) < 0) {
134 			free((char *)idp);
135 			break;
136 		}
137 		nidates++;
138 		idatev = (struct idates **)xrealloc((void *)idatev,
139 		    nidates * (size_t)sizeof (*idatev));
140 		idatev[nidates - 1] = idp;
141 	}
142 	/* LINTED: assigned value is used in inititimes */
143 	idates_in = 1;
144 }
145 
146 void
getitime(void)147 getitime(void)
148 {
149 	struct	idates	*ip;
150 	int	i;
151 	char	*fname;
152 
153 	/*
154 	 * if an alternate name was specified via the N flag, use it instead
155 	 * of the disk name.
156 	 */
157 	if (dname != NULL)
158 		fname = dname;
159 	else
160 		fname = disk;
161 
162 #ifdef FDEBUG
163 
164 	/* XGETTEXT:  #ifdef FDEBUG only */
165 	msg(gettext("Looking for name %s in increm = %s for delta = %c\n"),
166 	    fname, increm, (uchar_t)incno);
167 #endif
168 	spcl.c_ddate = 0;
169 	lastincno = '0';
170 
171 	inititimes();
172 	if (idatev == 0)
173 		return;
174 	/*
175 	 *	Go find the entry with the same name for a lower increment
176 	 *	and older date
177 	 */
178 	ITITERATE(i, ip) {
179 		if (strncmp(fname, ip->id_name, sizeof (ip->id_name)) != 0)
180 			continue;
181 		if (ip->id_incno >= incno)
182 			continue;
183 		if (ip->id_ddate <= spcl.c_ddate)
184 			continue;
185 		spcl.c_ddate = ip->id_ddate;
186 		lastincno = ip->id_incno;
187 	}
188 }
189 
190 void
putitime(void)191 putitime(void)
192 {
193 	FILE		*df;
194 	struct	idates	*itwalk;
195 	int		i;
196 	int		fd, saverr;
197 	char		*fname;
198 
199 	if (uflag == 0)
200 		return;
201 	if ((df = safe_fopen(increm, "r+", 0664)) == (FILE *)NULL) {
202 		msg("%s: %s\n", increm, strerror(errno));
203 		(void) unlink(increm);
204 		dumpabort();
205 		/*NOTREACHED*/
206 	}
207 	fd = fileno(df);
208 	(void) flock(fd, LOCK_EX);
209 
210 	/*
211 	 * if an alternate name was specified via the N flag, use it instead
212 	 * of the disk name.
213 	 */
214 	if (dname != NULL)
215 		fname = dname;
216 	else
217 		fname = disk;
218 
219 	if (idatev != 0) {
220 		for (i = 0; i < nidates && idatev[i] != 0; i++)
221 			free((char *)idatev[i]);
222 		free((char *)idatev);
223 	}
224 	idatev = 0;
225 	nidates = 0;
226 	readitimes(df);
227 	if (fseek(df, 0L, 0) < 0) {   /* rewind() was redefined in dumptape.c */
228 		saverr = errno;
229 		msg(gettext("%s: %s error:\n"),
230 		    increm, "fseek", strerror(saverr));
231 		dumpabort();
232 		/*NOTREACHED*/
233 	}
234 	spcl.c_ddate = 0;
235 	/* LINTED: won't dereference idatev if it is NULL (see readitimes) */
236 	ITITERATE(i, itwalk) {
237 		if (strncmp(fname, itwalk->id_name,
238 		    sizeof (itwalk->id_name)) != 0)
239 			continue;
240 		if (itwalk->id_incno != incno)
241 			continue;
242 		goto found;
243 	}
244 	/*
245 	 *	Add one more entry to idatev
246 	 */
247 	nidates++;
248 	idatev = (struct idates **)xrealloc((void *)idatev,
249 	    nidates * (size_t)sizeof (struct idates *));
250 	itwalk = idatev[nidates - 1] =
251 	    (struct idates *)xcalloc(1, sizeof (*itwalk));
252 found:
253 	(void) strncpy(itwalk->id_name, fname, sizeof (itwalk->id_name));
254 	itwalk->id_name[sizeof (itwalk->id_name) - 1] = '\0';
255 	itwalk->id_incno = incno;
256 	itwalk->id_ddate = spcl.c_date;
257 
258 	ITITERATE(i, itwalk) {
259 		recout(df, itwalk);
260 	}
261 	if (ftruncate64(fd, ftello64(df))) {
262 		saverr = errno;
263 		msg(gettext("%s: %s error:\n"),
264 		    increm, "ftruncate64", strerror(saverr));
265 		dumpabort();
266 		/*NOTREACHED*/
267 	}
268 	(void) fclose(df);
269 	msg(gettext("Level %c dump on %s\n"),
270 	    (uchar_t)incno, prdate(spcl.c_date));
271 }
272 
273 static void
recout(FILE * file,struct idates * what)274 recout(FILE *file, struct idates *what)
275 {
276 	time_t ddate = what->id_ddate;
277 	/* must use ctime, so we can later use unctime() */
278 	(void) fprintf(file, DUMPOUTFMT, what->id_name,
279 	    (uchar_t)what->id_incno, ctime(&ddate));
280 }
281 
282 static int
getrecord(FILE * df,struct idates * idatep)283 getrecord(FILE *df, struct idates *idatep)
284 {
285 	char		buf[BUFSIZ];
286 
287 	if ((fgets(buf, BUFSIZ, df)) != buf)
288 		return (-1);
289 	recno++;
290 	if (makeidate(idatep, buf) < 0) {
291 		msg(gettext(
292 		    "Malformed entry in dump record file `%s', line %d\n"),
293 		    increm, recno);
294 		if (strcmp(increm, NINCREM)) {
295 			msg(gettext("`%s' not a dump record file\n"), increm);
296 			dumpabort();
297 			/*NOTREACHED*/
298 		}
299 		return (-1);
300 	}
301 
302 #ifdef FDEBUG
303 	msg("getrecord: %s %c %s\n",
304 	    idatep->id_name,
305 	    (uchar_t)idatep->id_incno,
306 	    prdate(idatep->id_ddate));
307 #endif
308 	return (0);
309 }
310 
311 static int
makeidate(struct idates * ip,char * buf)312 makeidate(struct idates	*ip, char *buf)
313 {
314 	char	un_buf[128];	/* size must be >= second one in DUMPINFMT */
315 
316 	/*
317 	 * MAXNAMLEN has different values in dirent.h and ufs_fsdir.h,
318 	 * and we need to ensure that the length in DUMPINFMT matches
319 	 * what we allow for.  Can't just use MAXNAMLEN in the test,
320 	 * because there's no convenient way to substitute it into
321 	 * DUMPINFMT.
322 	 * XXX There's got to be a better way.
323 	 */
324 	/*LINTED [assertion always true]*/
325 	assert(sizeof (ip->id_name) == (255 + 3));
326 
327 	if (sscanf(buf, DUMPINFMT, ip->id_name, &ip->id_incno, un_buf) != 3)
328 		return (-1);
329 	/* LINTED casting from 64-bit to 32-bit time */
330 	ip->id_ddate = (time32_t)unctime(un_buf);
331 	if (ip->id_ddate < 0)
332 		return (-1);
333 	return (0);
334 }
335 
336 /*
337  * This is an estimation of the number of tp_bsize blocks in the file.
338  * It estimates the number of blocks in files with holes by assuming
339  * that all of the blocks accounted for by di_blocks are data blocks
340  * (when some of the blocks are usually used for indirect pointers);
341  * hence the estimate may be high.
342  */
343 void
est(struct dinode * ip)344 est(struct dinode *ip)
345 {
346 	u_offset_t s, t;
347 
348 	/*
349 	 * ip->di_size is the size of the file in bytes.
350 	 * ip->di_blocks stores the number of sectors actually in the file.
351 	 * If there are more sectors than the size would indicate, this just
352 	 *	means that there are indirect blocks in the file or unused
353 	 *	sectors in the last file block; we can safely ignore these
354 	 *	(s = t below).
355 	 * If the file is bigger than the number of sectors would indicate,
356 	 *	then the file has holes in it.	In this case we must use the
357 	 *	block count to estimate the number of data blocks used, but
358 	 *	we use the actual size for estimating the number of indirect
359 	 *	dump blocks (t vs. s in the indirect block calculation).
360 	 */
361 	o_esize++;
362 	s = (unsigned)(ip->di_blocks) / (unsigned)(tp_bsize / DEV_BSIZE);
363 	/* LINTED: spurious complaint about sign-extending 32 to 64 bits */
364 	t = d_howmany(ip->di_size, (unsigned)tp_bsize);
365 	if (s > t)
366 		s = t;
367 	if (ip->di_size > (u_offset_t)((unsigned)(sblock->fs_bsize) * NDADDR)) {
368 		/* calculate the number of indirect blocks on the dump tape */
369 		/* LINTED: spurious complaint sign-extending 32 to 64 bits */
370 		s += d_howmany(t -
371 		    (unsigned)(NDADDR * sblock->fs_bsize / tp_bsize),
372 		    (unsigned)TP_NINDIR);
373 	}
374 	f_esize += s;
375 }
376 
377 /*ARGSUSED*/
378 void
bmapest(uchar_t * map)379 bmapest(uchar_t *map)
380 {
381 	o_esize++;
382 	/* LINTED: spurious complaint sign-extending 32 to 64 bits */
383 	f_esize += d_howmany(msiz * sizeof (map[0]), (unsigned)tp_bsize);
384 }
385 
386 
387 /*
388  * Check to see if what we are trying to dump is a fs snapshot
389  * If so, we can use the snapshot's create time to populate
390  * the dumpdates file, instead of the time of the dump.
391  */
392 time32_t
is_fssnap_dump(char * disk)393 is_fssnap_dump(char *disk)
394 {
395 	struct stat st;
396 	char *last;
397 	int snapnum;
398 	kstat_ctl_t *kslib;
399 	kstat_t *ksnum;
400 	kstat_named_t *numval;
401 
402 	last = basename(disk);
403 	if ((strstr(disk, SNAP_NAME) == NULL) || (stat(disk, &st) == -1) ||
404 	    (isdigit(last[0]) == 0))
405 		return (0);
406 
407 	snapnum = atoi(last);
408 
409 	if ((kslib = kstat_open()) == NULL)
410 		return (0);
411 
412 	ksnum = kstat_lookup(kslib, SNAP_NAME, snapnum, FSSNAP_KSTAT_NUM);
413 	if (ksnum == NULL) {
414 		(void) kstat_close(kslib);
415 		return (0);
416 	}
417 
418 	if (kstat_read(kslib, ksnum, NULL) == -1) {
419 		(void) kstat_close(kslib);
420 		return (0);
421 	}
422 
423 	numval = kstat_data_lookup(ksnum, FSSNAP_KSTAT_NUM_CREATETIME);
424 	if (numval == NULL) {
425 		(void) kstat_close(kslib);
426 		return (0);
427 	}
428 
429 	(void) kstat_close(kslib);
430 	/* LINTED casting from long to 32-bit time */
431 	return (time32_t)(numval->value.l & INT_MAX);
432 }
433