[dump.git] / common / legacy_indexer.c

#include <config.h>
#include <compatlfs.h>
#include <ctype.h>
#include <compaterr.h>
#include <fcntl.h>
#include <fstab.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>

#include <sys/param.h>
#include <sys/time.h>
#include <time.h>
#ifdef __linux__
#include <linux/types.h>
#include <sys/stat.h>
#include <sys/mtio.h>
#include <bsdcompat.h>
#include <linux/fs.h>	/* for definition of BLKFLSBUF */
#elif defined sunos
#include <sys/vnode.h>

#include <ufs/inode.h>
#include <ufs/fs.h>
#else
#include <ufs/ufs/dinode.h>
#include <ufs/ffs/fs.h>
#endif

#include <protocols/dumprestore.h>

//#include "dump.h"
#include "indexer.h"
#include "slave.h"

extern dump_ino_t volinfo[];  // TP_NINOS
extern int tapeno;

static int Afile = -1;	/* archive file descriptor */
static int AfileActive = 1;/* Afile flag */

//extern char *Apath;
char *Apath;

#ifdef USE_QFA
static int GetTapePos __P((long long *));
static int MkTapeString __P((struct s_spcl *, long long));
#define FILESQFAPOS	20

int tapepos;
int ntrec;		/* blocking factor on tape */
int magtapeout;  /* is output a magnetic tape? */
//extern int tapepos;
//extern int ntrec;		/* blocking factor on tape */
//extern int magtapeout;  /* is output a magnetic tape? */

static int gtperr = 0;
static int gTapeposfd;
static char *gTapeposfile;
static char gTps[255];
static int32_t gThisDumpDate;
#endif /* USE_QFA */

void	msg __P((const char *fmt, ...));
void	quit __P((const char *fmt, ...));

extern char *host;
extern int tapefd;

/*
 * Open the indexer file.
 */
static int
legacy_open(const char *filename, int mode)
{
	if (filename == NULL) {
		return 0;
	}

	if (mode == 0) {
		if ((Afile = OPEN(filename, O_RDONLY)) < 0) {
			msg("Cannot open %s for reading: %s\n",
					filename, strerror(errno));
			msg("The ENTIRE dump is aborted.\n");
			return -1;
		}
	} else if (mode == 1) {
		if ((Afile = OPEN(filename, O_WRONLY|O_CREAT|O_TRUNC,
				   S_IRUSR | S_IWUSR | S_IRGRP |
				   S_IWGRP | S_IROTH | S_IWOTH)) < 0) {
			msg("Cannot open %s for writing: %s\n",
					filename, strerror(errno));
			msg("The ENTIRE dump is aborted.\n");
			return -1;
		}
	}

	return 0;
}

/*
 * Close the indexer file.
 */
static int
legacy_close()
{
	if (Afile >= 0)
		msg("Archiving dump to %s\n", Apath);
	return 0;
}

/*
 * Write a record to the indexer file.
 */
static int
legacy_writerec(const void *dp, int isspcl)
{
	if (! AfileActive && isspcl && (spcl.c_type == TS_END))
		AfileActive = 1;
	if (AfileActive && Afile >= 0 && !(spcl.c_flags & DR_EXTATTRIBUTES)) {
		/* When we dump an inode which is not a directory,
		 * it means we ended the archive contents */
		if (isspcl && (spcl.c_type == TS_INODE) &&
		    ((spcl.c_dinode.di_mode & S_IFMT) != IFDIR))
			AfileActive = 0;
		else {
			union u_spcl tmp;
			tmp = *(union u_spcl *)dp;
			/* Write the record, _uncompressed_ */
			if (isspcl) {
				tmp.s_spcl.c_flags &= ~DR_COMPRESSED;
				mkchecksum(&tmp);
			}
			if (write(Afile, &tmp, TP_BSIZE) != TP_BSIZE)
				msg("error writing archive file: %s\n",
			    	strerror(errno));
		}
	}
	return 0;
}

/*
 * I'm not sure what this is used for...
 */
static int
legacy_foo()
{
	if (Afile >= 0) {
		volinfo[1] = ROOTINO;
		memcpy(spcl.c_inos, volinfo, TP_NINOS * sizeof(dump_ino_t));
		spcl.c_flags |= DR_INODEINFO;
	}
	return 0;
}

/*
 * Dump inode
 */
static int
legacy_addInode(struct dinode *dp, dump_ino_t ino, int metaonly)
{
	return 0;
}

/*
 * Dump directory (dirent) entry
 */
static int
legacy_addDirEntry(struct direct *dp, dump_ino_t parent_ino)
{
	 return 0;
}


#define LSEEK_GET_TAPEPOS 	10
#define LSEEK_GO2_TAPEPOS	11

/*
 *
 */
static int
legacy_openQfa()
{
#ifdef USE_QFA
	gThisDumpDate = spcl.c_date;
	if (tapepos) {
		msg("writing QFA positions to %s\n", gTapeposfile);
		if ((gTapeposfd = open(gTapeposfile,
				       O_WRONLY|O_CREAT|O_TRUNC,
				       S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP
				       | S_IROTH | S_IWOTH)) < 0)
			quit("can't open tapeposfile\n");
		/* print QFA-file header */
		snprintf(gTps, sizeof(gTps), "%s\n%s\n%ld\n\n", QFA_MAGIC, QFA_VERSION, (unsigned long)spcl.c_date);
		gTps[sizeof(gTps) - 1] = '\0';
		if (write(gTapeposfd, gTps, strlen(gTps)) != (ssize_t)strlen(gTps))
			quit("can't write tapeposfile\n");
		sprintf(gTps, "ino\ttapeno\ttapepos\n");
		if (write(gTapeposfd, gTps, strlen(gTps)) != (ssize_t)strlen(gTps))
			quit("can't write tapeposfile\n");
	}
#endif /* USE_QFA */
	return 0;
}

/*
 *
 */
static int
legacy_closeQfa()
{
	return 0;
}

/*
 *
 */
static int
legacy_openQfaState(QFA_State *s)
{
	s->curtapepos = 0;
	s->maxntrecs = 50000;	/* every 50MB */
	s->cntntrecs = s->maxntrecs;
	return 0;
}

/*
 *
 */
static int
legacy_updateQfaState(QFA_State *s)
{
	if (gTapeposfd >= 0) {
		s->cntntrecs += ntrec;
	}

	return 0;
}


/*
 *
 */
static int
legacy_updateQfa(QFA_State *s)
{
#ifdef USE_QFA
	union u_spcl *uspclptr;
	struct s_spcl *spclptr;

	if (gTapeposfd >= 0) {
		int i;
		int foundone = 0;

		for (i = 0; (i < ntrec) && !foundone; ++i) {
			uspclptr = (union u_spcl *)&slp->tblock[i];
			spclptr = &uspclptr->s_spcl;
			if ((spclptr->c_magic == NFS_MAGIC) && 
						(spclptr->c_type == TS_INODE) &&
						(spclptr->c_date == gThisDumpDate) &&
						!(spclptr->c_dinode.di_mode & S_IFDIR) &&
						!(spclptr->c_flags & DR_EXTATTRIBUTES)
					) {
				foundone = 1;
				/* if (s->cntntrecs >= s->maxntrecs) {	 only write every maxntrecs amount of data */
					s->cntntrecs = 0;
					if (gtperr == 0) 
						gtperr = GetTapePos(&s->curtapepos);
					/* if an error occured previously don't
					 * try again */
					if (gtperr == 0) {
#ifdef DEBUG_QFA
						msg("inode %ld at tapepos %ld\n", spclptr->c_inumber, s->curtapepos);
#endif
						gtperr = MkTapeString(spclptr, s->curtapepos);
					}
				/* } */
			}
		}
	}
#endif /* USE_QFA */
	return 0;
}

#ifdef USE_QFA
/*
 * read the current tape position
 */
static int
GetTapePos(long long *pos)
{
	int err = 0;

#ifdef RDUMP
	if (host) {
		*pos = (long long) rmtseek((OFF_T)0, (int)LSEEK_GET_TAPEPOS);
		err = *pos < 0;
	}
	else 
#endif
	{
	if (magtapeout) {
		long mtpos;
		*pos = 0;
		err = (ioctl(tapefd, MTIOCPOS, &mtpos) < 0);
		*pos = (long long)mtpos;
	}
	else {
		*pos = LSEEK(tapefd, 0, SEEK_CUR);
		err = (*pos < 0);
	}
	}
	if (err) {
		err = errno;
		msg("[%ld] error: %d (getting tapepos: %lld)\n", getpid(), 
			err, *pos);
		return err;
	}
	return err;
}

static int 
MkTapeString(struct s_spcl *spclptr, long long curtapepos)
{
	int	err = 0;

#ifdef DEBUG_QFA
	msg("inode %ld at tapepos %lld\n", spclptr->c_inumber, curtapepos);
#endif

	snprintf(gTps, sizeof(gTps), "%ld\t%d\t%lld\n", 
		 (unsigned long)spclptr->c_inumber, 
		 tapeno, 
		 curtapepos);
	gTps[sizeof(gTps) - 1] = '\0';
	if (write(gTapeposfd, gTps, strlen(gTps)) != (ssize_t)strlen(gTps)) {
		err = errno;
      	warn("error writing tapepos file. (error %d)\n", errno);
	}
	return err;
}
#endif /* USE_QFA */

Indexer indexer_legacy = {
	NULL,
	&legacy_open,
	&legacy_close,
	&legacy_foo,
	&legacy_writerec,
	&legacy_addInode,
	&legacy_addDirEntry,
	&legacy_openQfa,
	&legacy_closeQfa,
	&legacy_updateQfa,
	&legacy_updateQfaState
};
Commit	Line	Data
70deb804 SP	1	#include <config.h>
	2	#include <compatlfs.h>
	3	#include <ctype.h>
	4	#include <compaterr.h>
	5	#include <fcntl.h>
	6	#include <fstab.h>
	7	#include <signal.h>
	8	#include <stdio.h>
	9	#include <stdlib.h>
	10	#include <string.h>
	11	#include <unistd.h>
	12	#include <errno.h>
	13
	14	#include <sys/param.h>
	15	#include <sys/time.h>
	16	#include <time.h>
	17	#ifdef __linux__
	18	#include <linux/types.h>
	19	#include <sys/stat.h>
	20	#include <sys/mtio.h>
	21	#include <bsdcompat.h>
	22	#include <linux/fs.h> /* for definition of BLKFLSBUF */
	23	#elif defined sunos
	24	#include <sys/vnode.h>
	25
	26	#include <ufs/inode.h>
	27	#include <ufs/fs.h>
	28	#else
	29	#include <ufs/ufs/dinode.h>
	30	#include <ufs/ffs/fs.h>
	31	#endif
	32
	33	#include <protocols/dumprestore.h>
	34
	35	//#include "dump.h"
	36	#include "indexer.h"
	37	#include "slave.h"
	38
	39	extern dump_ino_t volinfo[]; // TP_NINOS
	40	extern int tapeno;
	41
	42	static int Afile = -1; /* archive file descriptor */
	43	static int AfileActive = 1;/* Afile flag */
	44
	45	//extern char *Apath;
	46	char *Apath;
	47
	48	#ifdef USE_QFA
	49	static int GetTapePos __P((long long *));
	50	static int MkTapeString __P((struct s_spcl *, long long));
	51	#define FILESQFAPOS 20
	52
	53	int tapepos;
	54	int ntrec; /* blocking factor on tape */
	55	int magtapeout; /* is output a magnetic tape? */
	56	//extern int tapepos;
	57	//extern int ntrec; /* blocking factor on tape */
	58	//extern int magtapeout; /* is output a magnetic tape? */
	59
	60	static int gtperr = 0;
	61	static int gTapeposfd;
	62	static char *gTapeposfile;
	63	static char gTps[255];
	64	static int32_t gThisDumpDate;
65	#endif /* USE_QFA */
66
67	void msg __P((const char *fmt, ...));
68	void quit __P((const char *fmt, ...));
69
70	extern char *host;
71	extern int tapefd;
72
73	/*
74	* Open the indexer file.
75	*/
76	static int
77	legacy_open(const char *filename, int mode)
78	{
79	if (filename == NULL) {
80	return 0;
81	}
82
83	if (mode == 0) {
84	if ((Afile = OPEN(filename, O_RDONLY)) < 0) {
85	msg("Cannot open %s for reading: %s\n",
86	filename, strerror(errno));
87	msg("The ENTIRE dump is aborted.\n");
88	return -1;
89	}
90	} else if (mode == 1) {
91	if ((Afile = OPEN(filename, O_WRONLY\|O_CREAT\|O_TRUNC,
92	S_IRUSR \| S_IWUSR \| S_IRGRP \|
93	S_IWGRP \| S_IROTH \| S_IWOTH)) < 0) {
94	msg("Cannot open %s for writing: %s\n",
95	filename, strerror(errno));
96	msg("The ENTIRE dump is aborted.\n");
97	return -1;
98	}
99	}
100
101	return 0;
102	}
103
104	/*
105	* Close the indexer file.
106	*/
107	static int
108	legacy_close()
109	{
110	if (Afile >= 0)
111	msg("Archiving dump to %s\n", Apath);
112	return 0;
113	}
114
115	/*
116	* Write a record to the indexer file.
117	*/
118	static int
119	legacy_writerec(const void *dp, int isspcl)
120	{
121	if (! AfileActive && isspcl && (spcl.c_type == TS_END))
122	AfileActive = 1;
123	if (AfileActive && Afile >= 0 && !(spcl.c_flags & DR_EXTATTRIBUTES)) {
124	/* When we dump an inode which is not a directory,
125	* it means we ended the archive contents */
126	if (isspcl && (spcl.c_type == TS_INODE) &&
127	((spcl.c_dinode.di_mode & S_IFMT) != IFDIR))
128	AfileActive = 0;
129	else {
130	union u_spcl tmp;
131	tmp = (union u_spcl )dp;
132	/* Write the record, _uncompressed_ */
133	if (isspcl) {
134	tmp.s_spcl.c_flags &= ~DR_COMPRESSED;
135	mkchecksum(&tmp);
136	}
137	if (write(Afile, &tmp, TP_BSIZE) != TP_BSIZE)
138	msg("error writing archive file: %s\n",
139	strerror(errno));
140	}
141	}
142	return 0;
143	}
144
145	/*
146	* I'm not sure what this is used for...
147	*/
148	static int
149	legacy_foo()
150	{
151	if (Afile >= 0) {
152	volinfo[1] = ROOTINO;
153	memcpy(spcl.c_inos, volinfo, TP_NINOS * sizeof(dump_ino_t));
154	spcl.c_flags \|= DR_INODEINFO;
155	}
156	return 0;
157	}
158
159	/*
160	* Dump inode
161	*/
162	static int
163	legacy_addInode(struct dinode *dp, dump_ino_t ino, int metaonly)
164	{
165	return 0;
166	}
167
168	/*
169	* Dump directory (dirent) entry
170	*/
171	static int
172	legacy_addDirEntry(struct direct *dp, dump_ino_t parent_ino)
173	{
174	return 0;
175	}
176
177
178	#define LSEEK_GET_TAPEPOS 10
179	#define LSEEK_GO2_TAPEPOS 11
180
181	/*
182	*
183	*/
184	static int
185	legacy_openQfa()
186	{
187	#ifdef USE_QFA
188	gThisDumpDate = spcl.c_date;
189	if (tapepos) {
190	msg("writing QFA positions to %s\n", gTapeposfile);
191	if ((gTapeposfd = open(gTapeposfile,
192	O_WRONLY\|O_CREAT\|O_TRUNC,
193	S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IWGRP
194	\| S_IROTH \| S_IWOTH)) < 0)
195	quit("can't open tapeposfile\n");
196	/* print QFA-file header */
197	snprintf(gTps, sizeof(gTps), "%s\n%s\n%ld\n\n", QFA_MAGIC, QFA_VERSION, (unsigned long)spcl.c_date);
198	gTps[sizeof(gTps) - 1] = '\0';
199	if (write(gTapeposfd, gTps, strlen(gTps)) != (ssize_t)strlen(gTps))
200	quit("can't write tapeposfile\n");
201	sprintf(gTps, "ino\ttapeno\ttapepos\n");
202	if (write(gTapeposfd, gTps, strlen(gTps)) != (ssize_t)strlen(gTps))
203	quit("can't write tapeposfile\n");
204	}
205	#endif /* USE_QFA */
206	return 0;
207	}
208
209	/*
210	*
211	*/
212	static int
213	legacy_closeQfa()
214	{
215	return 0;
216	}
217
218	/*
219	*
220	*/
221	static int
222	legacy_openQfaState(QFA_State *s)
223	{
224	s->curtapepos = 0;
225	s->maxntrecs = 50000; /* every 50MB */
226	s->cntntrecs = s->maxntrecs;
227	return 0;
228	}
229
230	/*
231	*
232	*/
233	static int
234	legacy_updateQfaState(QFA_State *s)
235	{
236	if (gTapeposfd >= 0) {
237	s->cntntrecs += ntrec;
238	}
239
240	return 0;
241	}
242
243
244	/*
245	*
246	*/
247	static int
248	legacy_updateQfa(QFA_State *s)
249	{
250	#ifdef USE_QFA
251	union u_spcl *uspclptr;
252	struct s_spcl *spclptr;
253
254	if (gTapeposfd >= 0) {
255	int i;
256	int foundone = 0;
257
258	for (i = 0; (i < ntrec) && !foundone; ++i) {
259	uspclptr = (union u_spcl *)&slp->tblock[i];
260	spclptr = &uspclptr->s_spcl;
261	if ((spclptr->c_magic == NFS_MAGIC) &&
262	(spclptr->c_type == TS_INODE) &&
263	(spclptr->c_date == gThisDumpDate) &&
264	!(spclptr->c_dinode.di_mode & S_IFDIR) &&
265	!(spclptr->c_flags & DR_EXTATTRIBUTES)
266	) {
267	foundone = 1;
268	/* if (s->cntntrecs >= s->maxntrecs) { only write every maxntrecs amount of data */
269	s->cntntrecs = 0;
270	if (gtperr == 0)
271	gtperr = GetTapePos(&s->curtapepos);
272	/* if an error occured previously don't
273	* try again */
274	if (gtperr == 0) {
275	#ifdef DEBUG_QFA
276	msg("inode %ld at tapepos %ld\n", spclptr->c_inumber, s->curtapepos);
277	#endif
278	gtperr = MkTapeString(spclptr, s->curtapepos);
279	}
280	/* } */
281	}
282	}
283	}
284	#endif /* USE_QFA */
285	return 0;
286	}
287
288	#ifdef USE_QFA
289	/*
290	* read the current tape position
291	*/
292	static int
293	GetTapePos(long long *pos)
294	{
295	int err = 0;
296
297	#ifdef RDUMP
298	if (host) {
299	*pos = (long long) rmtseek((OFF_T)0, (int)LSEEK_GET_TAPEPOS);
300	err = *pos < 0;
301	}
302	else
303	#endif
304	{
305	if (magtapeout) {
306	long mtpos;
307	*pos = 0;
308	err = (ioctl(tapefd, MTIOCPOS, &mtpos) < 0);
309	*pos = (long long)mtpos;
310	}
311	else {
312	*pos = LSEEK(tapefd, 0, SEEK_CUR);
313	err = (*pos < 0);
314	}
315	}
316	if (err) {
317	err = errno;
318	msg("[%ld] error: %d (getting tapepos: %lld)\n", getpid(),
319	err, *pos);
320	return err;
321	}
322	return err;
323	}
324
325	static int
326	MkTapeString(struct s_spcl *spclptr, long long curtapepos)
327	{
328	int err = 0;
329
330	#ifdef DEBUG_QFA
331	msg("inode %ld at tapepos %lld\n", spclptr->c_inumber, curtapepos);
332	#endif
333
334	snprintf(gTps, sizeof(gTps), "%ld\t%d\t%lld\n",
335	(unsigned long)spclptr->c_inumber,
336	tapeno,
337	curtapepos);
338	gTps[sizeof(gTps) - 1] = '\0';
339	if (write(gTapeposfd, gTps, strlen(gTps)) != (ssize_t)strlen(gTps)) {
340	err = errno;
341	warn("error writing tapepos file. (error %d)\n", errno);
342	}
343	return err;
344	}
345	#endif /* USE_QFA */
346
347	Indexer indexer_legacy = {
348	NULL,
349	&legacy_open,
350	&legacy_close,
351	&legacy_foo,
352	&legacy_writerec,
353	&legacy_addInode,
354	&legacy_addDirEntry,
355	&legacy_openQfa,
356	&legacy_closeQfa,
357	&legacy_updateQfa,
358	&legacy_updateQfaState
359	};