litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Steven Whitehouse <swhiteho@redhat.com>	2006-10-03 11:10:41 -0400
committer	Steven Whitehouse <swhiteho@redhat.com>	2006-10-03 11:10:41 -0400
commit	ddacfaf76dd620af9b73343a975749778321b51c (patch)
tree	1199c2a78b5e2cdd6efc6965dd4cd8caa00ec482 /fs/gfs2/meta_io.c
parent	f92a0b6ff43e8e07bbd5b1d2dd1cff130014f3c7 (diff)

[GFS2] Move logging code into log.c (mostly)

This moves the logging code from meta_io.c into log.c and glops.c. As a result the routines can now be static and all the logging code is together in log.c, leaving meta_io.c with just metadata i/o code in it. Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>

Diffstat (limited to 'fs/gfs2/meta_io.c')

-rw-r--r--

fs/gfs2/meta_io.c

164

1 files changed, 0 insertions, 164 deletions


diff --git a/fs/gfs2/meta_io.c b/fs/gfs2/meta_io.c index d0d981dac4cd..3912d6a4b1e6 100644 --- a/fs/gfs2/meta_io.c +++ b/fs/gfs2/meta_io.c
@@ -34,11 +34,6 @@
34	#include "util.h"	34	#include "util.h"
35	#include "ops_address.h"	35	#include "ops_address.h"
36		36
37	#define buffer_busy(bh) \
38	((bh)->b_state & ((1ul << BH_Dirty) \| (1ul << BH_Lock) \| (1ul << BH_Pinned)))
39	#define buffer_in_io(bh) \
40	((bh)->b_state & ((1ul << BH_Dirty) \| (1ul << BH_Lock)))
41
42	static int aspace_get_block(struct inode *inode, sector_t lblock,	37	static int aspace_get_block(struct inode *inode, sector_t lblock,
43	struct buffer_head *bh_result, int create)	38	struct buffer_head *bh_result, int create)
44	{	39	{
@@ -92,165 +87,6 @@ void gfs2_aspace_put(struct inode *aspace)
92	}	87	}
93		88
94	/**	89	/**
95	* gfs2_ail1_start_one - Start I/O on a part of the AIL
96	* @sdp: the filesystem
97	* @tr: the part of the AIL
98	*
99	*/
100
101	void gfs2_ail1_start_one(struct gfs2_sbd sdp, struct gfs2_ail ai)
102	{
103	struct gfs2_bufdata bd, s;
104	struct buffer_head *bh;
105	int retry;
106
107	BUG_ON(!spin_is_locked(&sdp->sd_log_lock));
108
109	do {
110	retry = 0;
111
112	list_for_each_entry_safe_reverse(bd, s, &ai->ai_ail1_list,
113	bd_ail_st_list) {
114	bh = bd->bd_bh;
115
116	gfs2_assert(sdp, bd->bd_ail == ai);
117
118	if (!buffer_busy(bh)) {
119	if (!buffer_uptodate(bh)) {
120	gfs2_log_unlock(sdp);
121	gfs2_io_error_bh(sdp, bh);
122	gfs2_log_lock(sdp);
123	}
124	list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
125	continue;
126	}
127
128	if (!buffer_dirty(bh))
129	continue;
130
131	list_move(&bd->bd_ail_st_list, &ai->ai_ail1_list);
132
133	gfs2_log_unlock(sdp);
134	wait_on_buffer(bh);
135	ll_rw_block(WRITE, 1, &bh);
136	gfs2_log_lock(sdp);
137
138	retry = 1;
139	break;
140	}
141	} while (retry);
142	}
143
144	/**
145	* gfs2_ail1_empty_one - Check whether or not a trans in the AIL has been synced
146	* @sdp: the filesystem
147	* @ai: the AIL entry
148	*
149	*/
150
151	int gfs2_ail1_empty_one(struct gfs2_sbd sdp, struct gfs2_ail ai, int flags)
152	{
153	struct gfs2_bufdata bd, s;
154	struct buffer_head *bh;
155
156	list_for_each_entry_safe_reverse(bd, s, &ai->ai_ail1_list,
157	bd_ail_st_list) {
158	bh = bd->bd_bh;
159
160	gfs2_assert(sdp, bd->bd_ail == ai);
161
162	if (buffer_busy(bh)) {
163	if (flags & DIO_ALL)
164	continue;
165	else
166	break;
167	}
168
169	if (!buffer_uptodate(bh))
170	gfs2_io_error_bh(sdp, bh);
171
172	list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
173	}
174
175	return list_empty(&ai->ai_ail1_list);
176	}
177
178	/**
179	* gfs2_ail2_empty_one - Check whether or not a trans in the AIL has been synced
180	* @sdp: the filesystem
181	* @ai: the AIL entry
182	*
183	*/
184
185	void gfs2_ail2_empty_one(struct gfs2_sbd sdp, struct gfs2_ail ai)
186	{
187	struct list_head *head = &ai->ai_ail2_list;
188	struct gfs2_bufdata *bd;
189
190	while (!list_empty(head)) {
191	bd = list_entry(head->prev, struct gfs2_bufdata,
192	bd_ail_st_list);
193	gfs2_assert(sdp, bd->bd_ail == ai);
194	bd->bd_ail = NULL;
195	list_del(&bd->bd_ail_st_list);
196	list_del(&bd->bd_ail_gl_list);
197	atomic_dec(&bd->bd_gl->gl_ail_count);
198	brelse(bd->bd_bh);
199	}
200	}
201
202	/**
203	* ail_empty_gl - remove all buffers for a given lock from the AIL
204	* @gl: the glock
205	*
206	* None of the buffers should be dirty, locked, or pinned.
207	*/
208
209	void gfs2_ail_empty_gl(struct gfs2_glock *gl)
210	{
211	struct gfs2_sbd *sdp = gl->gl_sbd;
212	unsigned int blocks;
213	struct list_head *head = &gl->gl_ail_list;
214	struct gfs2_bufdata *bd;
215	struct buffer_head *bh;
216	u64 blkno;
217	int error;
218
219	blocks = atomic_read(&gl->gl_ail_count);
220	if (!blocks)
221	return;
222
223	error = gfs2_trans_begin(sdp, 0, blocks);
224	if (gfs2_assert_withdraw(sdp, !error))
225	return;
226
227	gfs2_log_lock(sdp);
228	while (!list_empty(head)) {
229	bd = list_entry(head->next, struct gfs2_bufdata,
230	bd_ail_gl_list);
231	bh = bd->bd_bh;
232	blkno = bh->b_blocknr;
233	gfs2_assert_withdraw(sdp, !buffer_busy(bh));
234
235	bd->bd_ail = NULL;
236	list_del(&bd->bd_ail_st_list);
237	list_del(&bd->bd_ail_gl_list);
238	atomic_dec(&gl->gl_ail_count);
239	brelse(bh);
240	gfs2_log_unlock(sdp);
241
242	gfs2_trans_add_revoke(sdp, blkno);
243
244	gfs2_log_lock(sdp);
245	}
246	gfs2_assert_withdraw(sdp, !atomic_read(&gl->gl_ail_count));
247	gfs2_log_unlock(sdp);
248
249	gfs2_trans_end(sdp);
250	gfs2_log_flush(sdp, NULL);
251	}
252
253	/**
254	* gfs2_meta_inval - Invalidate all buffers associated with a glock	90	* gfs2_meta_inval - Invalidate all buffers associated with a glock
255	* @gl: the glock	91	* @gl: the glock
256	*	92	*

351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428

/* * docproc is a simple preprocessor for the template files * used as placeholders for the kernel internal documentation. * docproc is used for documentation-frontend and * dependency-generator. * The two usages have in common that they require * some knowledge of the .tmpl syntax, therefore they * are kept together. * * documentation-frontend * Scans the template file and call kernel-doc for * all occurrences of ![EIF]file * Beforehand each referenced file is scanned for * any symbols that are exported via these macros: * EXPORT_SYMBOL(), EXPORT_SYMBOL_GPL(), & * EXPORT_SYMBOL_GPL_FUTURE() * This is used to create proper -function and * -nofunction arguments in calls to kernel-doc. * Usage: docproc doc file.tmpl * * dependency-generator: * Scans the template file and list all files * referenced in a format recognized by make. * Usage: docproc depend file.tmpl * Writes dependency information to stdout * in the following format: * file.tmpl src.c src2.c * The filenames are obtained from the following constructs: * !Efilename * !Ifilename * !Dfilename * !Ffilename * !Pfilename * */ #define _GNU_SOURCE #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> #include <unistd.h> #include <limits.h> #include <errno.h> #include <sys/types.h> #include <sys/wait.h> /* exitstatus is used to keep track of any failing calls to kernel-doc, * but execution continues. */ int exitstatus = 0; typedef void DFL(char *); DFL *defaultline; typedef void FILEONLY(char * file); FILEONLY *internalfunctions; FILEONLY *externalfunctions; FILEONLY *symbolsonly; FILEONLY *findall; typedef void FILELINE(char * file, char * line); FILELINE * singlefunctions; FILELINE * entity_system; FILELINE * docsection; #define MAXLINESZ 2048 #define MAXFILES 250 #define KERNELDOCPATH "scripts/" #define KERNELDOC "kernel-doc" #define DOCBOOK "-docbook" #define LIST "-list" #define FUNCTION "-function" #define NOFUNCTION "-nofunction" #define NODOCSECTIONS "-no-doc-sections" static char *srctree, *kernsrctree; static char **all_list = NULL; static int all_list_len = 0; static void consume_symbol(const char *sym) { int i; for (i = 0; i < all_list_len; i++) { if (!all_list[i]) continue; if (strcmp(sym, all_list[i])) continue; all_list[i] = NULL; break; } } static void usage (void) { fprintf(stderr, "Usage: docproc {doc|depend} file\n"); fprintf(stderr, "Input is read from file.tmpl. Output is sent to stdout\n"); fprintf(stderr, "doc: frontend when generating kernel documentation\n"); fprintf(stderr, "depend: generate list of files referenced within file\n"); fprintf(stderr, "Environment variable SRCTREE: absolute path to sources.\n"); fprintf(stderr, " KBUILD_SRC: absolute path to kernel source tree.\n"); } /* * Execute kernel-doc with parameters given in svec */ static void exec_kernel_doc(char **svec) { pid_t pid; int ret; char real_filename[PATH_MAX + 1]; /* Make sure output generated so far are flushed */ fflush(stdout); switch (pid=fork()) { case -1: perror("fork"); exit(1); case 0: memset(real_filename, 0, sizeof(real_filename)); strncat(real_filename, kernsrctree, PATH_MAX); strncat(real_filename, "/" KERNELDOCPATH KERNELDOC, PATH_MAX - strlen(real_filename)); execvp(real_filename, svec); fprintf(stderr, "exec "); perror(real_filename); exit(1); default: waitpid(pid, &ret ,0); } if (WIFEXITED(ret)) exitstatus |= WEXITSTATUS(ret); else exitstatus = 0xff; } /* Types used to create list of all exported symbols in a number of files */ struct symbols { char *name; }; struct symfile { char *filename; struct symbols *symbollist; int symbolcnt; }; struct symfile symfilelist[MAXFILES]; int symfilecnt = 0; static void add_new_symbol(struct symfile *sym, char * symname) { sym->symbollist = realloc(sym->symbollist, (sym->symbolcnt + 1) * sizeof(char *)); sym->symbollist[sym->symbolcnt++].name = strdup(symname); } /* Add a filename to the list */ static struct symfile * add_new_file(char * filename) { symfilelist[symfilecnt++].filename = strdup(filename); return &symfilelist[symfilecnt - 1]; } /* Check if file already are present in the list */ static struct symfile * filename_exist(char * filename) { int i; for (i=0; i < symfilecnt; i++) if (strcmp(symfilelist[i].filename, filename) == 0) return &symfilelist[i]; return NULL; } /* * List all files referenced within the template file. * Files are separated by tabs. */ static void adddep(char * file) { printf("\t%s", file); } static void adddep2(char * file, char * line) { line = line; adddep(file); } static void noaction(char * line) { line = line; } static void noaction2(char * file, char * line) { file = file; line = line; } /* Echo the line without further action */ static void printline(char * line) { printf("%s", line); } /* * Find all symbols in filename that are exported with EXPORT_SYMBOL & * EXPORT_SYMBOL_GPL (& EXPORT_SYMBOL_GPL_FUTURE implicitly). * All symbols located are stored in symfilelist. */ static void find_export_symbols(char * filename) { FILE * fp; struct symfile *sym; char line[MAXLINESZ]; if (filename_exist(filename) == NULL) { char real_filename[PATH_MAX + 1]; memset(real_filename, 0, sizeof(real_filename)); strncat(real_filename, srctree, PATH_MAX); strncat(real_filename, "/", PATH_MAX - strlen(real_filename)); strncat(real_filename, filename, PATH_MAX - strlen(real_filename)); sym = add_new_file(filename); fp = fopen(real_filename, "r"); if (fp == NULL) { fprintf(stderr, "docproc: "); perror(real_filename); exit(1); } while (fgets(line, MAXLINESZ, fp)) { char *p; char *e; if (((p = strstr(line, "EXPORT_SYMBOL_GPL")) != NULL) || ((p = strstr(line, "EXPORT_SYMBOL")) != NULL)) { /* Skip EXPORT_SYMBOL{_GPL} */ while (isalnum(*p) || *p == '_') p++; /* Remove parentheses & additional whitespace */ while (isspace(*p)) p++; if (*p != '(') continue; /* Syntax error? */ else p++; while (isspace(*p)) p++; e = p; while (isalnum(*e) || *e == '_') e++; *e = '\0'; add_new_symbol(sym, p); } } fclose(fp); } } /* * Document all external or internal functions in a file. * Call kernel-doc with following parameters: * kernel-doc -docbook -nofunction function_name1 filename * Function names are obtained from all the src files * by find_export_symbols. * intfunc uses -nofunction * extfunc uses -function */ static void docfunctions(char * filename, char * type) { int i,j; int symcnt = 0; int idx = 0; char **vec; for (i=0; i <= symfilecnt; i++) symcnt += symfilelist[i].symbolcnt; vec = malloc((2 + 2 * symcnt + 3) * sizeof(char *)); if (vec == NULL) { perror("docproc: "); exit(1); } vec[idx++] = KERNELDOC; vec[idx++] = DOCBOOK; vec[idx++] = NODOCSECTIONS; for (i=0; i < symfilecnt; i++) { struct symfile * sym = &symfilelist[i]; for (j=0; j < sym->symbolcnt; j++) { vec[idx++] = type; consume_symbol(sym->symbollist[j].name); vec[idx++] = sym->symbollist[j].name; } } vec[idx++] = filename; vec[idx] = NULL; printf("\n", filename); exec_kernel_doc(vec); fflush(stdout); free(vec); } static void intfunc(char * filename) { docfunctions(filename, NOFUNCTION); } static void extfunc(char * filename) { docfunctions(filename, FUNCTION); } /* * Document specific function(s) in a file. * Call kernel-doc with the following parameters: * kernel-doc -docbook -function function1 [-function function2] */ static void singfunc(char * filename, char * line) { char *vec[200]; /* Enough for specific functions */ int i, idx = 0; int startofsym = 1; vec[idx++] = KERNELDOC; vec[idx++] = DOCBOOK; /* Split line up in individual parameters preceded by FUNCTION */ for (i=0; line[i]; i++) { if (isspace(line[i])) { line[i] = '\0'; startofsym = 1; continue; } if (startofsym) { startofsym = 0; vec[idx++] = FUNCTION; vec[idx++] = &line[i]; } } for (i = 0; i < idx; i++) { if (strcmp(vec[i], FUNCTION)) continue; consume_symbol(vec[i + 1]); } vec[idx++] = filename; vec[idx] = NULL; exec_kernel_doc(vec); } /* * Insert specific documentation section from a file. * Call kernel-doc with the following parameters: * kernel-doc -docbook -function "doc section" filename */ static void docsect(char *filename, char *line) { char *vec[6]; /* kerneldoc -docbook -function "section" file NULL */ char *s; for (s = line; *s; s++) if (*s == '\n') *s = '\0'; if (asprintf(&s, "DOC: %s", line) < 0) { perror("asprintf"); exit(1); } consume_symbol(s); free(s); vec[0] = KERNELDOC; vec[1] = DOCBOOK; vec[2] = FUNCTION; vec[3] = line; vec[4] = filename; vec[5] = NULL; exec_kernel_doc(vec); } static void find_all_symbols(char *filename) { char *vec[4]; /* kerneldoc -list file NULL */ pid_t pid; int ret, i, count, start; char real_filename[PATH_MAX + 1]; int pipefd[2]; char *data, *str; size_t data_len = 0; vec[0] = KERNELDOC; vec[1] = LIST; vec[2] = filename; vec[3] = NULL; if (pipe(pipefd)) { perror("pipe"); exit(1); } switch (pid=fork()) { case -1: perror("fork"); exit(1); case 0: close(pipefd[0]); dup2(pipefd[1], 1); memset(real_filename, 0, sizeof(real_filename)); strncat(real_filename, kernsrctree, PATH_MAX); strncat(real_filename, "/" KERNELDOCPATH KERNELDOC, PATH_MAX - strlen(real_filename)); execvp(real_filename, vec); fprintf(stderr, "exec "); perror(real_filename); exit(1); default: close(pipefd[1]); data = malloc(4096); do { while ((ret = read(pipefd[0], data + data_len, 4096)) > 0) { data_len += ret; data = realloc(data, data_len + 4096); } } while (ret == -EAGAIN); if (ret != 0) { perror("read"); exit(1); } waitpid(pid, &ret ,0); } if (WIFEXITED(ret)) exitstatus |= WEXITSTATUS(ret); else exitstatus = 0xff; count = 0; /* poor man's strtok, but with counting */ for (i = 0; i < data_len; i++) { if (data[i] == '\n') { count++; data[i] = '\0'; } } start = all_list_len; all_list_len += count; all_list = realloc(all_list, sizeof(char *) * all_list_len); str = data; for (i = 0; i < data_len && start != all_list_len; i++) { if (data[i] == '\0') { all_list[start] = str; str = data + i + 1; start++; } } } /* * Parse file, calling action specific functions for: * 1) Lines containing !E * 2) Lines containing !I * 3) Lines containing !D * 4) Lines containing !F * 5) Lines containing !P * 6) Lines containing !C * 7) Default lines - lines not matching the above */ static void parse_file(FILE *infile) { char line[MAXLINESZ]; char * s; while (fgets(line, MAXLINESZ, infile)) { if (line[0] == '!') { s = line + 2; switch (line[1]) { case 'E': while (*s && !isspace(*s)) s++; *s = '\0'; externalfunctions(line+2); break; case 'I': while (*s && !isspace(*s)) s++; *s = '\0'; internalfunctions(line+2); break; case 'D': while (*s && !isspace(*s)) s++; *s = '\0'; symbolsonly(line+2); break; case 'F': /* filename */ while (*s && !isspace(*s)) s++; *s++ = '\0'; /* function names */ while (isspace(*s)) s++; singlefunctions(line +2, s); break; case 'P': /* filename */ while (*s && !isspace(*s)) s++; *s++ = '\0'; /* DOC: section name */ while (isspace(*s)) s++; docsection(line + 2, s); break; case 'C': while (*s && !isspace(*s)) s++; *s = '\0'; if (findall) findall(line+2); break; default: defaultline(line); } } else { defaultline(line); } } fflush(stdout); } int main(int argc, char *argv[]) { FILE * infile; int i; srctree = getenv("SRCTREE"); if (!srctree) srctree = getcwd(NULL, 0); kernsrctree = getenv("KBUILD_SRC"); if (!kernsrctree || !*kernsrctree) kernsrctree = srctree; if (argc != 3) { usage(); exit(1); } /* Open file, exit on error */ infile = fopen(argv[2], "r"); if (infile == NULL) { fprintf(stderr, "docproc: "); perror(argv[2]); exit(2); } if (strcmp("doc", argv[1]) == 0) { /* Need to do this in two passes. * First pass is used to collect all symbols exported * in the various files; * Second pass generate the documentation. * This is required because some functions are declared * and exported in different files :-(( */ /* Collect symbols */ defaultline = noaction; internalfunctions = find_export_symbols; externalfunctions = find_export_symbols; symbolsonly = find_export_symbols; singlefunctions = noaction2; docsection = noaction2; findall = find_all_symbols; parse_file(infile); /* Rewind to start from beginning of file again */ fseek(infile, 0, SEEK_SET); defaultline = printline; internalfunctions = intfunc; externalfunctions = extfunc; symbolsonly = printline; singlefunctions = singfunc; docsection = docsect; findall = NULL; parse_file(infile); for (i = 0; i < all_list_len; i++) { if (!all_list[i]) continue; fprintf(stderr, "Warning: didn't use docs for %s\n", all_list[i]); } } else if (strcmp("depend", argv[1]) == 0) { /* Create first part of dependency chain * file.tmpl */ printf("%s\t", argv[2]); defaultline = noaction; internalfunctions = adddep; externalfunctions = adddep; symbolsonly = adddep; singlefunctions = adddep2; docsection = adddep2; findall = adddep; parse_file(infile); printf("\n"); } else { fprintf(stderr, "Unknown option: %s\n", argv[1]); exit(1); } fclose(infile); fflush(stdout); return exitstatus; }


context:
space:
mode: