[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

Re: [Cluster-devel] [PATCH] libgfs2: Add a gfs2 block query language



Hi,

Looks good. Thats a big step forward for us I think,

Steve.

On Fri, 2012-10-12 at 19:51 +0100, Andrew Price wrote:
> This patch adds a small language which we can use to write libgfs2 and
> gfs2-utils tests (among other things). It provides 'get' and 'set'
> statements which look up and modify gfs2 blocks. The language API is
> defined as:
> 
>    struct lgfs2_lang_state;
> 
>    struct lgfs2_lang_result {
>            uint64_t lr_blocknr;
>            struct gfs2_buffer_head *lr_bh;
>            const struct lgfs2_metadata *lr_mtype;
>            int lr_state; // GFS2_BLKST_*
>    };
> 
>    struct lgfs2_lang_state *lgfs2_lang_init(void);
>    void lgfs2_lang_free(struct lgfs2_lang_state **state);
> 
>    int lgfs2_lang_parsef(struct lgfs2_lang_state *state, FILE *script);
>    int lgfs2_lang_parses(struct lgfs2_lang_state *state, const char *script);
> 
>    struct lgfs2_lang_result *lgfs2_lang_result_next(struct lgfs2_lang_state *state, struct gfs2_sbd *sbd);
>    int lgfs2_lang_result_print(struct lgfs2_lang_result *result);
>    void lgfs2_lang_result_free(struct lgfs2_lang_result **result);
> 
> The lgfs2_lang_parse{s,f} functions allow you to parse a string or a
> file respectively. Using the same state object you can then run the same
> script multiple times, without parsing it again, using
> lgfs2_lang_interpret(). The intended usage of these functions can be
> shown with a simple example (error checking omitted):
> 
>    struct lgfs2_lang_state *state = lgfs2_lang_init();
>    lgfs2_lang_parses(state, "get sb; get 1234 state; set '/foo/bar' {di_entries: 3}");
>    for (result = lgfs2_lang_result_next(state, &sbd);
>         result != NULL;
>         result = lgfs2_lang_result_next(state, &sbd)) {
>            lgfs2_lang_result_print(result);
>            lgfs2_lang_result_free(&result);
>    }
>    lgfs2_lang_free(&state);
> 
> The language has a simple syntax:
> 
>    get <block_lookup> [state]
>    set <block_lookup> {<field0>:<value0>, <field1>:<value1>, ... }
> 
> A block lookup can be a file system block address (1234 or 0x1234), a
> resource group subscript (rgrp[0], rgrp[0x5]), a keyword (sb, master,
> root, rindex) or an offset from any of the above (1234+5, rgrp[1]+23,
> rindex+68, ...).
> 
> After the block lookup, the 'get' statement takes an optional keyword
> 'state' which allows you to query the bitmap state of the block.
> 
> Examples of 'get':
> 
>    get rgrp[1]+23 state
>    --> result.lr_state == GFS2_BLKST_FREE
> 
>    get rindex
>    --> result.lr_bh is a buffer containing the rindex dinode.
>    --> result.lr_mtype is the block's metatype as defined in meta.c.
> 
> The 'set' statement requires a list of field-value pairs which are to be
> modified in the block. The field names must match the names shown when
> running the 'get' statement with the same block lookup.
> 
> Examples of 'set':
> 
>    set '/foo/bar/baz' { di_entries: 3 }
>    --> result.lr_bh contains the dinode block at path /foo/bar/baz, with
>        the di_entries field modified.
>    --> result.lr_mtype is the block's metatype as defined in meta.c.
> 
>    set sb { sb_lockproto: 'lock_dlm', sb_bsize: 0x1000 }
>    --> result.lr_bh contains the superblock with the lockproto changed to
>        lock_dlm and the block size changed to 4096.
>    --> result.lr_mtype is the block's metatype as defined in meta.c.
> 
> Whitespace is insignificant in the language and semicolons can be used
> to separate multiple statements. When writing longer scripts spanning
> multiple lines, C-like // syntax can be used to insert comments.
> 
> Signed-off-by: Andrew Price <anprice redhat com>
> ---
>  .gitignore               |   7 +
>  configure.ac             |   2 +
>  gfs2/libgfs2/Makefile.am |  13 +-
>  gfs2/libgfs2/buf.c       |  10 +
>  gfs2/libgfs2/fs_ops.c    |   6 +-
>  gfs2/libgfs2/lang.c      | 603 +++++++++++++++++++++++++++++++++++++++++++++++
>  gfs2/libgfs2/lang.h      |  61 +++++
>  gfs2/libgfs2/lexer.l     | 101 ++++++++
>  gfs2/libgfs2/libgfs2.h   |  24 ++
>  gfs2/libgfs2/meta.c      |  50 ++++
>  gfs2/libgfs2/misc.c      |   2 -
>  gfs2/libgfs2/parser.y    | 186 +++++++++++++++
>  gfs2/libgfs2/super.c     |   2 +-
>  13 files changed, 1057 insertions(+), 10 deletions(-)
>  create mode 100644 gfs2/libgfs2/lang.c
>  create mode 100644 gfs2/libgfs2/lang.h
>  create mode 100644 gfs2/libgfs2/lexer.l
>  create mode 100644 gfs2/libgfs2/parser.y
> 
> diff --git a/.gitignore b/.gitignore
> index e8b7ea1..4e3071a 100644
> --- a/.gitignore
> +++ b/.gitignore
> @@ -21,6 +21,9 @@ make/stamp-h1
>  m4
>  make/clusterautoconfig.h*
>  missing
> +ylwrap
> +cscope.out
> +.gdb_history
>  *.pc
>  .deps
>  .libs
> @@ -29,6 +32,10 @@ missing
>  *.lo
>  gfs2/convert/gfs2_convert
>  gfs2/edit/gfs2_edit
> +gfs2/libgfs2/parser.c
> +gfs2/libgfs2/parser.h
> +gfs2/libgfs2/lexer.c
> +gfs2/libgfs2/lexer.h
>  gfs2/fsck/fsck.gfs2
>  gfs2/mkfs/mkfs.gfs2
>  gfs2/mount/mount.gfs2
> diff --git a/configure.ac b/configure.ac
> index d56cfac..ef09569 100644
> --- a/configure.ac
> +++ b/configure.ac
> @@ -56,6 +56,8 @@ AM_PROG_CC_C_O
>  AC_PROG_LN_S
>  AC_PROG_INSTALL
>  AC_PROG_MAKE_SET
> +AC_PROG_LEX
> +AC_PROG_YACC
>  
>  ## local helper functions
>  
> diff --git a/gfs2/libgfs2/Makefile.am b/gfs2/libgfs2/Makefile.am
> index 4e60b0a..7103e09 100644
> --- a/gfs2/libgfs2/Makefile.am
> +++ b/gfs2/libgfs2/Makefile.am
> @@ -1,15 +1,24 @@
>  MAINTAINERCLEANFILES	= Makefile.in
>  
> -noinst_HEADERS		= libgfs2.h
> +CLEANFILES		= parser.h parser.c lexer.c lexer.h
> +BUILT_SOURCES		= parser.h lexer.h
> +AM_LFLAGS		= --header-file=lexer.h
> +AM_YFLAGS		= -d
> +
> +noinst_HEADERS		= libgfs2.h lang.h
>  
>  noinst_LTLIBRARIES	= libgfs2.la
>  
>  libgfs2_la_SOURCES	= block_list.c fs_bits.c gfs1.c misc.c rgrp.c super.c \
>  			  buf.c fs_geometry.c gfs2_disk_hash.c ondisk.c \
>  			  device_geometry.c fs_ops.c gfs2_log.c recovery.c \
> -			  structures.c meta.c
> +			  structures.c meta.c lang.c parser.y lexer.l
>  
>  libgfs2_la_CPPFLAGS	= -D_FILE_OFFSET_BITS=64 \
>  			  -D_LARGEFILE64_SOURCE \
>  			  -D_GNU_SOURCE \
>  			  -I$(top_srcdir)/gfs2/include
> +
> +# Autotools can't handle header files output by flex so we have to generate it manually
> +lexer.h: lexer.l
> +	$(LEX) -o lexer.c $(AM_LFLAGS) $^
> diff --git a/gfs2/libgfs2/buf.c b/gfs2/libgfs2/buf.c
> index 956dd8b..5bc1a4e 100644
> --- a/gfs2/libgfs2/buf.c
> +++ b/gfs2/libgfs2/buf.c
> @@ -83,3 +83,13 @@ int brelse(struct gfs2_buffer_head *bh)
>  	free(bh);
>  	return error;
>  }
> +
> +uint32_t lgfs2_get_block_type(const struct gfs2_buffer_head *lbh)
> +{
> +	const struct gfs2_meta_header *mh = lbh->iov.iov_base;
> +
> +	if (be32_to_cpu(mh->mh_magic) == GFS2_MAGIC)
> +		return be32_to_cpu(mh->mh_type);
> +
> +	return 0;
> +}
> diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c
> index ec150e8..3d027e8 100644
> --- a/gfs2/libgfs2/fs_ops.c
> +++ b/gfs2/libgfs2/fs_ops.c
> @@ -1759,11 +1759,7 @@ int gfs2_lookupi(struct gfs2_inode *dip, const char *filename, int len,
>  		return 0;
>  	}
>  	error = dir_search(dip, filename, len, NULL, &inum);
> -	if (error) {
> -		if (error == -ENOENT)
> -			return 0;
> -	}
> -	else
> +	if (!error)
>  		*ipp = lgfs2_inode_read(sdp, inum.no_addr);
>  
>  	return error;
> diff --git a/gfs2/libgfs2/lang.c b/gfs2/libgfs2/lang.c
> new file mode 100644
> index 0000000..12ca7bd
> --- /dev/null
> +++ b/gfs2/libgfs2/lang.c
> @@ -0,0 +1,603 @@
> +#include <stdint.h>
> +#include <string.h>
> +#include <stdlib.h>
> +#include <stdio.h>
> +#include <sys/queue.h>
> +#include <errno.h>
> +#include <limits.h>
> +#include <ctype.h>
> +
> +#include "parser.h"
> +#include "lang.h"
> +
> +const char* ast_type_string[] = {
> +	[AST_NONE] = "NONE",
> +	// Statements
> +	[AST_ST_SET] = "SET",
> +	[AST_ST_GET] = "GET",
> +
> +	// Expressions
> +	[AST_EX_ID] = "IDENTIFIER",
> +	[AST_EX_NUMBER] = "NUMBER",
> +	[AST_EX_STRING] = "STRING",
> +	[AST_EX_ADDRESS] = "ADDRESS",
> +	[AST_EX_PATH] = "PATH",
> +	[AST_EX_SUBSCRIPT] = "SUBSCRIPT",
> +	[AST_EX_OFFSET] = "OFFSET",
> +	[AST_EX_BLOCKSPEC] = "BLOCKSPEC",
> +	[AST_EX_STRUCTSPEC] = "STRUCTSPEC",
> +	[AST_EX_FIELDSPEC] = "FIELDSPEC",
> +
> +	// Keywords
> +	[AST_KW_STATE] = "STATE",
> +};
> +
> +/**
> + * Initialize an expression node of the given type from a source string.
> + * Currently just converts numerical values and string values where
> + * appropriate. String values are duplicted into newly allocated buffers as the
> + * text from the parser will go away.
> + * Returns 0 on success or non-zero with errno set on failure
> + */
> +static int ast_expr_init(struct ast_node *expr, ast_node_t type, const char *str)
> +{
> +	int ret = 0;
> +	switch (type) {
> +	case AST_EX_OFFSET:
> +		str++; // Cut off the +
> +	case AST_EX_NUMBER:
> +		ret = sscanf(str, "%"SCNi64, &expr->ast_num);
> +		if (ret != 1) {
> +			return 1;
> +		}
> +		break;
> +	case AST_EX_ID:
> +	case AST_EX_PATH:
> +	case AST_EX_STRING:
> +		expr->ast_str = strdup(str);
> +		if (expr->ast_str == NULL) {
> +			return 1;
> +		}
> +		break;
> +	case AST_EX_ADDRESS:
> +	case AST_EX_SUBSCRIPT:
> +	case AST_EX_BLOCKSPEC:
> +	case AST_EX_STRUCTSPEC:
> +	case AST_EX_FIELDSPEC:
> +	case AST_KW_STATE:
> +		break;
> +	default:
> +		errno = EINVAL;
> +		return 1;
> +	}
> +	return 0;
> +}
> +
> +/**
> + * Create a new AST node of a given type from a source string.
> + * Returns a pointer to the new node or NULL on failure with errno set.
> + */
> +struct ast_node *ast_new(ast_node_t type, const char *text)
> +{
> +	struct ast_node *node;
> +	node = (struct ast_node *)calloc(1, sizeof(struct ast_node));
> +	if (node == NULL) {
> +		goto return_fail;
> +	}
> +
> +	if (type > _AST_EX_START && ast_expr_init(node, type, text)) {
> +		goto return_free;
> +	}
> +
> +	node->ast_text = strdup(text);
> +	if (node->ast_text == NULL) {
> +		goto return_free;
> +	}
> +	node->ast_type = type;
> +
> +	return node;
> +
> +return_free:
> +	if (node->ast_text) {
> +		free(node->ast_text);
> +	}
> +	if (node->ast_str) {
> +		free(node->ast_str);
> +	}
> +	free(node);
> +return_fail:
> +	fprintf(stderr, "Failed to create new value from %s: %s\n", text, strerror(errno));
> +	return NULL;
> +}
> +
> +/**
> + * Free the memory allocated for an AST node and set its pointer to NULL
> + */
> +void ast_destroy(struct ast_node **node)
> +{
> +	if (*node == NULL) {
> +		return;
> +	}
> +	ast_destroy(&(*node)->ast_left);
> +	ast_destroy(&(*node)->ast_right);
> +	switch((*node)->ast_type) {
> +	case AST_EX_ID:
> +	case AST_EX_PATH:
> +	case AST_EX_STRING:
> +		free((*node)->ast_str);
> +		break;
> +	default:
> +		break;
> +	}
> +	free((*node)->ast_text);
> +	free(*node);
> +	*node = NULL;
> +}
> +
> +static void ast_string_unescape(char *str)
> +{
> +	int head, tail;
> +	for (head = tail = 0; str[head] != '\0'; head++, tail++) {
> +		if (str[head] == '\\' && str[head+1] != '\0')
> +			head++;
> +		str[tail] = str[head];
> +	}
> +	str[tail] = '\0';
> +}
> +
> +static uint64_t ast_lookup_path(char *path, struct gfs2_sbd *sbd)
> +{
> +	int err = 0;
> +	char *c;
> +	struct gfs2_inode *ip, *iptmp;
> +	char *segment;
> +	uint64_t bn = 0;
> +
> +	segment = strtok_r(path, "/", &c);
> +	ip = lgfs2_inode_read(sbd, sbd->sd_sb.sb_root_dir.no_addr);
> +
> +	while (ip != NULL) {
> +		if (segment == NULL) { // No more segments
> +			bn = ip->i_di.di_num.no_addr;
> +			inode_put(&ip);
> +			return bn;
> +		}
> +		ast_string_unescape(segment);
> +		err = gfs2_lookupi(ip, segment, strlen(segment), &iptmp);
> +		inode_put(&ip);
> +		if (err != 0) {
> +			errno = -err;
> +			break;
> +		}
> +		ip = iptmp;
> +		segment = strtok_r(NULL, "/", &c);
> +	}
> +
> +	perror("Path lookup");
> +	return 0;
> +}
> +
> +enum block_id {
> +	ID_SB	= 0,
> +	ID_MASTER,
> +	ID_ROOT,
> +	ID_RINDEX,
> +
> +	ID_END
> +};
> +
> +/**
> + * Names of blocks which can be uniquely identified in the fs
> + */
> +static const char *block_ids[] = {
> +	[ID_SB]		= "sb",
> +	[ID_MASTER]	= "master",
> +	[ID_ROOT]	= "root",
> +	[ID_RINDEX]	= "rindex",
> +
> +	[ID_END]	= NULL
> +};
> +
> +static uint64_t ast_lookup_id(const char *id, struct gfs2_sbd *sbd)
> +{
> +	uint64_t bn = 0;
> +	int i;
> +	for (i = 0; i < ID_END; i++) {
> +		if (!strcmp(id, block_ids[i])) {
> +			break;
> +		}
> +	}
> +	switch (i) {
> +	case ID_SB:
> +		bn = sbd->sb_addr;
> +		break;
> +	case ID_MASTER:
> +		bn = sbd->sd_sb.sb_master_dir.no_addr;
> +		break;
> +	case ID_ROOT:
> +		bn = sbd->sd_sb.sb_root_dir.no_addr;
> +		break;
> +	case ID_RINDEX:
> +		bn = sbd->md.riinode->i_di.di_num.no_addr;
> +		break;
> +	default:
> +		return 0;
> +	}
> +	return bn;
> +}
> +
> +static uint64_t ast_lookup_rgrp(uint64_t rgnum, struct gfs2_sbd *sbd)
> +{
> +	uint64_t i = rgnum;
> +	struct osi_node *n;
> +
> +	for (n = osi_first(&sbd->rgtree); n != NULL && i > 0; n = osi_next(n), i--);
> +	if (n != NULL && i == 0)
> +		return ((struct rgrp_tree *)n)->ri.ri_addr;
> +	fprintf(stderr, "Resource group number out of range: %"PRIu64"\n", rgnum);
> +	return 0;
> +}
> +
> +static uint64_t ast_lookup_subscript(struct ast_node *id, struct ast_node *index,
> +                                     struct gfs2_sbd *sbd)
> +{
> +	uint64_t bn = 0;
> +	const char *name = id->ast_str;
> +	if (!strcmp(name, "rgrp")) {
> +		bn = ast_lookup_rgrp(index->ast_num, sbd);
> +	} else {
> +		fprintf(stderr, "Unrecognized identifier %s\n", name);
> +	}
> +	return bn;
> +}
> +
> +/**
> + * Look up a block and return its number. The kind of lookup depends on the
> + * type of the ast node.
> + */
> +static uint64_t ast_lookup_block_num(struct ast_node *ast, struct gfs2_sbd *sbd)
> +{
> +	uint64_t bn = 0;
> +	switch (ast->ast_type) {
> +	case AST_EX_OFFSET:
> +		bn = ast_lookup_block_num(ast->ast_left, sbd) + ast->ast_num;
> +		break;
> +	case AST_EX_ADDRESS:
> +		bn = ast->ast_num;
> +		break;
> +	case AST_EX_PATH:
> +		bn = ast_lookup_path(ast->ast_str, sbd);
> +		break;
> +	case AST_EX_ID:
> +		bn = ast_lookup_id(ast->ast_str, sbd);
> +		break;
> +	case AST_EX_SUBSCRIPT:
> +		bn = ast_lookup_subscript(ast->ast_left, ast->ast_left->ast_left, sbd);
> +		break;
> +	default:
> +		break;
> +	}
> +	return bn;
> +}
> +
> +static struct gfs2_buffer_head *ast_lookup_block(struct ast_node *node, struct gfs2_sbd *sbd)
> +{
> +	uint64_t bn = ast_lookup_block_num(node, sbd);
> +	if (bn == 0) {
> +		return NULL;
> +	}
> +
> +	return bread(sbd, bn);
> +}
> +
> +static const char *bitstate_strings[] = {
> +	[GFS2_BLKST_FREE] = "Free",
> +	[GFS2_BLKST_USED] = "Used",
> +	[GFS2_BLKST_UNLINKED] = "Unlinked",
> +	[GFS2_BLKST_DINODE] = "Dinode"
> +};
> +
> +/**
> + * Print a representation of an arbitrary GFS2 block to stdout
> + */
> +int lgfs2_lang_result_print(struct lgfs2_lang_result *result)
> +{
> +	int i;
> +	if (result->lr_mtype != NULL) {
> +		for (i = 0; i < result->lr_mtype->nfields; i++) {
> +			lgfs2_field_print(result->lr_bh, result->lr_mtype, &result->lr_mtype->fields[i]);
> +		}
> +	} else {
> +		printf("%"PRIu64": %s\n", result->lr_blocknr, bitstate_strings[result->lr_state]);
> +	}
> +	return 0;
> +}
> +
> +static int ast_get_bitstate(uint64_t bn, struct gfs2_sbd *sbd)
> +{
> +	int ret = 0;
> +	int state = 0;
> +	struct rgrp_tree *rgd = gfs2_blk2rgrpd(sbd, bn);
> +	if (rgd == NULL) {
> +		fprintf(stderr, "Could not find resource group for block %"PRIu64"\n", bn);
> +		return -1;
> +	}
> +
> +	ret = gfs2_rgrp_read(sbd, rgd);
> +	if (ret != 0) {
> +		fprintf(stderr, "Failed to read resource group for block %"PRIu64": %d\n", bn, ret);
> +		return -1;
> +	}
> +
> +	state = gfs2_get_bitmap(sbd, bn, rgd);
> +	if (state == -1) {
> +		fprintf(stderr, "Failed to acquire bitmap state for block %"PRIu64"\n", bn);
> +		return -1;
> +	}
> +
> +	gfs2_rgrp_relse(rgd);
> +	return state;
> +}
> +
> +static const struct lgfs2_metadata *ast_lookup_mtype(const struct gfs2_buffer_head *bh)
> +{
> +	const struct lgfs2_metadata *mtype;
> +	const uint32_t mh_type = lgfs2_get_block_type(bh);
> +	if (mh_type == 0) {
> +		fprintf(stderr, "Could not determine type for block %"PRIu64"\n", bh->b_blocknr);
> +		return NULL;
> +	}
> +
> +	mtype = lgfs2_find_mtype(mh_type, bh->sdp->gfs1 ? LGFS2_MD_GFS1 : LGFS2_MD_GFS2);
> +	if (mtype == NULL) {
> +		fprintf(stderr, "Could not determine meta type for block %"PRIu64"\n", bh->b_blocknr);
> +		return NULL;
> +	}
> +	return mtype;
> +}
> +
> +/**
> + * Interpret the get statement.
> + */
> +static struct lgfs2_lang_result *ast_interp_get(struct lgfs2_lang_state *state,
> +                                     struct ast_node *ast, struct gfs2_sbd *sbd)
> +{
> +	struct lgfs2_lang_result *result = calloc(1, sizeof(struct lgfs2_lang_result));
> +	if (result == NULL) {
> +		fprintf(stderr, "Failed to allocate memory for result\n");
> +		return NULL;
> +	}
> +
> +	if (ast->ast_right->ast_right == NULL) {
> +		result->lr_bh = ast_lookup_block(ast->ast_right, sbd);
> +		if (result->lr_bh == NULL) {
> +			free(result);
> +			return NULL;
> +		}
> +		result->lr_blocknr = result->lr_bh->b_blocknr;
> +		result->lr_mtype = ast_lookup_mtype(result->lr_bh);
> +
> +	} else if (ast->ast_right->ast_right->ast_type == AST_KW_STATE) {
> +		result->lr_blocknr = ast_lookup_block_num(ast->ast_right, sbd);
> +		if (result->lr_blocknr == 0) {
> +			return NULL;
> +		}
> +		result->lr_state = ast_get_bitstate(result->lr_blocknr, sbd);
> +	}
> +
> +	return result;
> +}
> +
> +/**
> + * Interpret a UUID string by removing hyphens from the string and then
> + * interprets 16 pairs of hex digits as octets.
> + */
> +static int ast_str_to_uuid(const char *str, uint8_t *uuid)
> +{
> +	char s[33];
> +	int head, tail, tmp;
> +
> +	for (head = tail = 0; head < strlen(str) && tail < 33; head++) {
> +		if (str[head] == '-')
> +			continue;
> +		s[tail] = tolower(str[head]);
> +		if (!((s[tail] >= 'a' && s[tail] <= 'f') ||
> +		      (s[tail] >= '0' && s[tail] <= '9')))
> +			goto invalid;
> +		tail++;
> +	}
> +	if (tail != 32) {
> +		goto invalid;
> +	}
> +	s[tail] = '\0';
> +	for (head = 0; head < 16; head++) {
> +		if (sscanf(s+(head*2), "%02x", &tmp) != 1) {
> +			goto invalid;
> +		}
> +		*(uuid + head) = tmp;
> +	}
> +	return AST_INTERP_SUCCESS;
> +invalid:
> +	fprintf(stderr, "Invalid UUID\n");
> +	return AST_INTERP_INVAL;
> +}
> +
> +/**
> + * Set a field of a gfs2 block of a given type to a given value.
> + * Returns AST_INTERP_* to signal success, an invalid field/value or an error.
> + */
> +static int ast_field_set(struct gfs2_buffer_head *bh, const struct lgfs2_metafield *field,
> +                                                                        struct ast_node *val)
> +{
> +	char *fieldp = (char *)bh->iov.iov_base + field->offset;
> +
> +	if (field->flags & LGFS2_MFF_UUID) {
> +		uint8_t uuid[16];
> +		int ret = ast_str_to_uuid(val->ast_str, uuid);
> +
> +		if (ret != AST_INTERP_SUCCESS)
> +			return ret;
> +
> +		memcpy(fieldp, uuid, 16);
> +		bmodified(bh);
> +		return AST_INTERP_SUCCESS;
> +	}
> +
> +	if ((field->flags & LGFS2_MFF_STRING) && strlen(val->ast_str) > field->length) {
> +		fprintf(stderr, "String '%s' is too long for field '%s'\n", val->ast_str, field->name);
> +		return AST_INTERP_INVAL;
> +	}
> +
> +	if (field->flags & (LGFS2_MFF_STRING|LGFS2_MFF_UUID)) {
> +		strncpy(fieldp, val->ast_str, field->length - 1);
> +		fieldp[field->length - 1] = '\0';
> +		bmodified(bh);
> +		return AST_INTERP_SUCCESS;
> +	} else {
> +		// Numeric fields
> +		switch(field->length) {
> +		case 1:
> +			if (val->ast_num > UINT8_MAX)
> +				break;
> +			*fieldp = (uint8_t)val->ast_num;
> +			bmodified(bh);
> +			return AST_INTERP_SUCCESS;
> +		case 2:
> +			if (val->ast_num > UINT16_MAX)
> +				break;
> +			*(uint16_t *)fieldp = cpu_to_be16((uint16_t)val->ast_num);
> +			bmodified(bh);
> +			return AST_INTERP_SUCCESS;
> +		case 4:
> +			if (val->ast_num > UINT32_MAX)
> +				break;
> +			*(uint32_t *)fieldp = cpu_to_be32((uint32_t)val->ast_num);
> +			bmodified(bh);
> +			return AST_INTERP_SUCCESS;
> +		case 8:
> +			*(uint64_t *)fieldp = cpu_to_be64((uint64_t)val->ast_num);
> +			bmodified(bh);
> +			return AST_INTERP_SUCCESS;
> +		default:
> +			// This should never happen
> +			return AST_INTERP_ERR;
> +		}
> +	}
> +
> +	fprintf(stderr, "Invalid field assignment: %s (size %d) = %s\n",
> +	                     field->name, field->length, val->ast_text);
> +	return AST_INTERP_INVAL;
> +}
> +
> +/**
> + * Interpret an assignment (set)
> + */
> +static struct lgfs2_lang_result *ast_interp_set(struct lgfs2_lang_state *state,
> +                                    struct ast_node *ast, struct gfs2_sbd *sbd)
> +{
> +	struct ast_node *lookup = ast->ast_right;
> +	struct ast_node *fieldspec;
> +	struct ast_node *fieldname;
> +	struct ast_node *fieldval;
> +	uint32_t mh_type = 0;
> +	int i = 0;
> +	int ret = 0;
> +
> +	struct lgfs2_lang_result *result = calloc(1, sizeof(struct lgfs2_lang_result));
> +	if (result == NULL) {
> +		fprintf(stderr, "Failed to allocate memory for result\n");
> +		return NULL;
> +	}
> +
> +	result->lr_bh = ast_lookup_block(lookup, sbd);
> +	if (result->lr_bh == NULL) {
> +		goto out_err;
> +	}
> +
> +	mh_type = lgfs2_get_block_type(result->lr_bh);
> +	if (mh_type == 0) {
> +		goto out_err;
> +	}
> +
> +	result->lr_mtype = lgfs2_find_mtype(mh_type, sbd->gfs1 ? LGFS2_MD_GFS1 : LGFS2_MD_GFS2);
> +	if (result->lr_mtype == NULL) {
> +		goto out_err;
> +	}
> +
> +	for (fieldspec = lookup->ast_right;
> +	     fieldspec != NULL && fieldspec->ast_type == AST_EX_FIELDSPEC;
> +	     fieldspec = fieldspec->ast_left) {
> +
> +		fieldname = fieldspec->ast_right;
> +		fieldval = fieldname->ast_right;
> +		for (i = 0; i < result->lr_mtype->nfields; i++) {
> +			if (!strcmp(result->lr_mtype->fields[i].name, fieldname->ast_str)) {
> +				ret = ast_field_set(result->lr_bh, &result->lr_mtype->fields[i], fieldval);
> +				if (ret != AST_INTERP_SUCCESS) {
> +					goto out_err;
> +				}
> +				break;
> +			}
> +		}
> +	}
> +
> +	ret = bwrite(result->lr_bh);
> +	if (ret != 0) {
> +		fprintf(stderr, "Failed to write modified block %"PRIu64": %s\n",
> +		                        result->lr_bh->b_blocknr, strerror(errno));
> +		goto out_err;
> +	}
> +
> +	return result;
> +
> +out_err:
> +	lgfs2_lang_result_free(&result);
> +	return NULL;
> +}
> +
> +static struct lgfs2_lang_result *ast_interpret_node(struct lgfs2_lang_state *state,
> +                                        struct ast_node *ast, struct gfs2_sbd *sbd)
> +{
> +	struct lgfs2_lang_result *result = NULL;
> +
> +	if (ast->ast_type == AST_ST_SET) {
> +		result = ast_interp_set(state, ast, sbd);
> +	} else if (ast->ast_type == AST_ST_GET) {
> +		result = ast_interp_get(state, ast, sbd);
> +	} else {
> +		fprintf(stderr, "Invalid AST node type: %d\n", ast->ast_type);
> +	}
> +	return result;
> +}
> +
> +struct lgfs2_lang_result *lgfs2_lang_result_next(struct lgfs2_lang_state *state,
> +                                                           struct gfs2_sbd *sbd)
> +{
> +	struct lgfs2_lang_result *result;
> +	if (state->ls_interp_curr == NULL) {
> +		return NULL;
> +	}
> +	result = ast_interpret_node(state, state->ls_interp_curr, sbd);
> +	if (result == NULL) {
> +		return NULL;
> +	}
> +	state->ls_interp_curr = state->ls_interp_curr->ast_left;
> +	return result;
> +}
> +
> +void lgfs2_lang_result_free(struct lgfs2_lang_result **result)
> +{
> +	if (*result == NULL) {
> +		fprintf(stderr, "Warning: attempted to free a null result\n");
> +		return;
> +	}
> +
> +	if ((*result)->lr_mtype != NULL) {
> +		(*result)->lr_bh->b_modified = 0;
> +		brelse((*result)->lr_bh);
> +		(*result)->lr_bh = NULL;
> +	}
> +
> +	free(*result);
> +	*result = NULL;
> +}
> diff --git a/gfs2/libgfs2/lang.h b/gfs2/libgfs2/lang.h
> new file mode 100644
> index 0000000..955e52e
> --- /dev/null
> +++ b/gfs2/libgfs2/lang.h
> @@ -0,0 +1,61 @@
> +#ifndef LANG_H
> +#define LANG_H
> +#include <stdint.h>
> +#include "libgfs2.h"
> +
> +struct lgfs2_lang_state {
> +	int ls_colnum;
> +	int ls_linenum;
> +	int ls_errnum;
> +	struct ast_node *ls_ast_root;
> +	struct ast_node *ls_ast_tail;
> +	struct ast_node *ls_interp_curr;
> +};
> +
> +typedef enum {
> +	AST_NONE,
> +	// Statements
> +	AST_ST_SET,
> +	AST_ST_GET,
> +
> +	_AST_EX_START,
> +	// Expressions
> +	AST_EX_ID,
> +	AST_EX_NUMBER,
> +	AST_EX_STRING,
> +	AST_EX_ADDRESS,
> +	AST_EX_PATH,
> +	AST_EX_SUBSCRIPT,
> +	AST_EX_OFFSET,
> +	AST_EX_BLOCKSPEC,
> +	AST_EX_STRUCTSPEC,
> +	AST_EX_FIELDSPEC,
> +
> +	// Keywords
> +	AST_KW_STATE,
> +} ast_node_t;
> +
> +enum {
> +	AST_INTERP_SUCCESS	= 0, // Success
> +	AST_INTERP_FAIL		= 1, // Failure
> +	AST_INTERP_INVAL	= 2, // Invalid field/type mismatch
> +	AST_INTERP_ERR		= 3, // Something went wrong, see errno
> +};
> +
> +extern const char* ast_type_string[];
> +
> +struct ast_node {
> +	ast_node_t ast_type;
> +	struct ast_node *ast_left;
> +	struct ast_node *ast_right;
> +	char *ast_text;
> +	char *ast_str;
> +	uint64_t ast_num;
> +};
> +
> +extern struct ast_node *ast_new(ast_node_t type, const char *text);
> +extern void ast_destroy(struct ast_node **val);
> +
> +#define YYSTYPE struct ast_node *
> +
> +#endif /* LANG_H */
> diff --git a/gfs2/libgfs2/lexer.l b/gfs2/libgfs2/lexer.l
> new file mode 100644
> index 0000000..36e1c2d
> --- /dev/null
> +++ b/gfs2/libgfs2/lexer.l
> @@ -0,0 +1,101 @@
> +%{
> +#include "lang.h"
> +#include "parser.h"
> +
> +#define EXTRA ((struct lgfs2_lang_state *)yyextra)
> +
> +#define P(token, type, text) do {\
> +	*(yylval) = ast_new(type, text);\
> +	if (*(yylval) == NULL) {\
> +		EXTRA->ls_errnum = errno;\
> +		return 1;\
> +	}\
> +	return (TOK_##token);\
> +} while(0)
> +
> +#define COLNUM EXTRA->ls_colnum
> +#define YY_USER_ACTION COLNUM += yyleng;
> +
> +%}
> +%option bison-bridge reentrant
> +%option warn debug
> +%option nounput noinput
> +%option noyywrap
> +%option extra-type="struct lgfs2_lang_state *"
> +
> +letter			[a-zA-Z_]
> +decdigit		[0-9]
> +decnumber		-?{decdigit}+
> +hexdigit		[0-9a-fA-F]
> +hexnumber		-?0x{hexdigit}+
> +number			({decnumber}|{hexnumber})
> +offset			\+{number}
> +id			{letter}({letter}|{decdigit}|\.)*
> +string			\'([^\']|\\\')*\'
> +comment			\/\/.*\n
> +whitespace		[ \t\r]+
> +
> +%%
> +
> +\{			{
> +			return TOK_LBRACE;
> +			}
> +\}			{
> +			return TOK_RBRACE;
> +			}
> +\[			{
> +			return TOK_LBRACKET;
> +			}
> +\]			{
> +			P(RBRACKET, AST_EX_SUBSCRIPT, "[ ]");
> +			}
> +\,			{
> +			return TOK_COMMA;
> +			}
> +\:			{
> +			P(COLON, AST_EX_FIELDSPEC, yytext);
> +			}
> +\;			{
> +			return TOK_SEMI;
> +			}
> +set			{
> +			P(SET, AST_ST_SET, yytext);
> +			}
> +get			{
> +			P(GET, AST_ST_GET, yytext);
> +			}
> +state			{
> +			P(STATE, AST_KW_STATE, yytext);
> +			}
> +{string}		{
> +			yytext[yyleng-1] = '\0';
> +			P(STRING, AST_EX_STRING, yytext + 1);
> +			}
> +{offset}		{
> +			P(OFFSET, AST_EX_OFFSET, yytext);
> +			}
> +{number}		{
> +			P(NUMBER, AST_EX_NUMBER, yytext);
> +			}
> +{id}			{
> +			P(ID, AST_EX_ID, yytext);
> +			}
> +{comment}		{
> +			COLNUM = 0;
> +			EXTRA->ls_linenum++;
> +			}
> +<<EOF>>			{
> +			return 0;
> +			}
> +\n			{
> +			COLNUM = 0;
> +			EXTRA->ls_linenum++;
> +			}
> +{whitespace}		;
> +.			{
> +			printf("Unexpected character '%s' on line %d column %d\n",
> +			       yytext, yylineno, COLNUM);
> +			return 1;
> +			}
> +
> +%%
> diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
> index 74ee2d0..3045337 100644
> --- a/gfs2/libgfs2/libgfs2.h
> +++ b/gfs2/libgfs2/libgfs2.h
> @@ -356,6 +356,10 @@ extern const unsigned lgfs2_ld_type_size;
>  extern const struct lgfs2_symbolic lgfs2_ld1_types[];
>  extern const unsigned lgfs2_ld1_type_size;
>  extern int lgfs2_selfcheck(void);
> +extern const struct lgfs2_metadata *lgfs2_find_mtype(uint32_t mh_type, const unsigned versions);
> +extern int lgfs2_field_print(const struct gfs2_buffer_head *bh,
> +                             const struct lgfs2_metadata *mtype,
> +                             const struct lgfs2_metafield *field);
>  
>  /* bitmap.c */
>  struct gfs2_bmap {
> @@ -379,6 +383,7 @@ extern struct gfs2_buffer_head *__bread(struct gfs2_sbd *sdp, uint64_t num,
>  					int line, const char *caller);
>  extern int bwrite(struct gfs2_buffer_head *bh);
>  extern int brelse(struct gfs2_buffer_head *bh);
> +extern uint32_t lgfs2_get_block_type(const struct gfs2_buffer_head *lbh);
>  
>  #define bmodified(bh) do { bh->b_modified = 1; } while(0)
>  
> @@ -828,6 +833,25 @@ extern void gfs2_log_descriptor_print(struct gfs2_log_descriptor *ld);
>  extern void gfs2_statfs_change_print(struct gfs2_statfs_change *sc);
>  extern void gfs2_quota_change_print(struct gfs2_quota_change *qc);
>  
> +/* Language functions */
> +
> +struct lgfs2_lang_state;
> +
> +struct lgfs2_lang_result {
> +	uint64_t lr_blocknr;
> +	struct gfs2_buffer_head *lr_bh;
> +	const struct lgfs2_metadata *lr_mtype;
> +	int lr_state; // GFS2_BLKST_*
> +};
> +
> +extern struct lgfs2_lang_state *lgfs2_lang_init(void);
> +extern int lgfs2_lang_parsef(struct lgfs2_lang_state *state, FILE *script);
> +extern int lgfs2_lang_parses(struct lgfs2_lang_state *state, const char *script);
> +extern struct lgfs2_lang_result *lgfs2_lang_result_next(struct lgfs2_lang_state *state, struct gfs2_sbd *sbd);
> +extern int lgfs2_lang_result_print(struct lgfs2_lang_result *result);
> +extern void lgfs2_lang_result_free(struct lgfs2_lang_result **result);
> +extern void lgfs2_lang_free(struct lgfs2_lang_state **state);
> +
>  __END_DECLS
>  
>  #endif /* __LIBGFS2_DOT_H__ */
> diff --git a/gfs2/libgfs2/meta.c b/gfs2/libgfs2/meta.c
> index a677cdc..29bf239 100644
> --- a/gfs2/libgfs2/meta.c
> +++ b/gfs2/libgfs2/meta.c
> @@ -808,3 +808,53 @@ int lgfs2_selfcheck(void)
>  	return ret;
>  }
>  
> +const struct lgfs2_metadata *lgfs2_find_mtype(uint32_t mh_type, const unsigned versions)
> +{
> +	const struct lgfs2_metadata *m = lgfs2_metadata;
> +	unsigned n = 0;
> +
> +	do {
> +		if ((m[n].versions & versions) && m[n].mh_type == mh_type)
> +			return &m[n];
> +		n++;
> +	} while (n < lgfs2_metadata_size);
> +
> +	return NULL;
> +}
> +
> +/**
> + * Print a representation of an arbitrary field of an arbitrary GFS2 block to stdout
> + * Returns 0 if successful, 1 otherwise
> + */
> +int lgfs2_field_print(const struct gfs2_buffer_head *bh, const struct lgfs2_metadata *mtype,
> +                      const struct lgfs2_metafield *field)
> +{
> +	const char *fieldp = (char *)bh->iov.iov_base + field->offset;
> +
> +	printf("%s\t%"PRIu64"\t%u\t%u\t%s\t", mtype->name, bh->b_blocknr, field->offset, field->length, field->name);
> +	if (field->flags & LGFS2_MFF_UUID) {
> +		printf("'%s'\n", str_uuid((const unsigned char *)fieldp));
> +	} else if (field->flags & LGFS2_MFF_STRING) {
> +		printf("'%s'\n", fieldp);
> +	} else {
> +		switch(field->length) {
> +		case 1:
> +			printf("%"PRIu8"\n", *(uint8_t *)fieldp);
> +			break;
> +		case 2:
> +			printf("%"PRIu16"\n", be16_to_cpu(*(uint16_t *)fieldp));
> +			break;
> +		case 4:
> +			printf("%"PRIu32"\n", be32_to_cpu(*(uint32_t *)fieldp));
> +			break;
> +		case 8:
> +			printf("%"PRIu64"\n", be64_to_cpu(*(uint64_t *)fieldp));
> +			break;
> +		default:
> +			// "Reserved" field so just print 0
> +			printf("0\n");
> +			return 1;
> +		}
> +	}
> +	return 0;
> +}
> diff --git a/gfs2/libgfs2/misc.c b/gfs2/libgfs2/misc.c
> index a68da4a..c2eb245 100644
> --- a/gfs2/libgfs2/misc.c
> +++ b/gfs2/libgfs2/misc.c
> @@ -26,8 +26,6 @@
>  #define SYS_BASE "/sys/fs/gfs2" /* FIXME: Look in /proc/mounts to find this */
>  #define DIV_RU(x, y) (((x) + (y) - 1) / (y))
>  
> -static char sysfs_buf[PAGE_SIZE];
> -
>  int compute_heightsize(struct gfs2_sbd *sdp, uint64_t *heightsize,
>  	uint32_t *maxheight, uint32_t bsize1, int diptrs, int inptrs)
>  {
> diff --git a/gfs2/libgfs2/parser.y b/gfs2/libgfs2/parser.y
> new file mode 100644
> index 0000000..084d15e
> --- /dev/null
> +++ b/gfs2/libgfs2/parser.y
> @@ -0,0 +1,186 @@
> +%code top {
> +#include <errno.h>
> +#include "lang.h"
> +#include "lexer.h"
> +
> +static int yyerror(struct lgfs2_lang_state *state, yyscan_t lexer, const char *errorstr)
> +{
> +	fprintf(stderr, "%d:%d: %s\n", state->ls_linenum, state->ls_colnum, errorstr);
> +	return 1;
> +}
> +
> +}
> +%defines
> +%debug
> +%define api.pure
> +%parse-param { struct lgfs2_lang_state *state }
> +%parse-param { yyscan_t lexer }
> +%lex-param { yyscan_t lexer }
> +%start script
> +%token TOK_COLON
> +%token TOK_COMMA
> +%token TOK_ID
> +%token TOK_LBRACE
> +%token TOK_LBRACKET
> +%token TOK_NUMBER
> +%token TOK_OFFSET
> +%token TOK_RBRACE
> +%token TOK_RBRACKET
> +%token TOK_SEMI
> +%token TOK_SET
> +%token TOK_GET
> +%token TOK_STATE
> +%token TOK_STRING
> +%%
> +script:		statements		{
> +			state->ls_ast_root = $1;
> +			state->ls_interp_curr = $1;
> +		}
> +		| statements TOK_SEMI	{
> +			state->ls_ast_root = $1;
> +			state->ls_interp_curr = $1;
> +		}
> +;
> +statements:	statements TOK_SEMI statement	{
> +			state->ls_ast_tail->ast_left = $3;
> +			state->ls_ast_tail = $3;
> +			$$ = $1;
> +		}
> +		| statement		{
> +			if (state->ls_ast_tail == NULL)
> +				state->ls_ast_tail = $1;
> +			$$ = $1;
> +		}
> +;
> +
> +statement:	set_stmt		{ $$ = $1; }
> +		| get_stmt		{ $$ = $1; }
> +;
> +set_stmt:	TOK_SET blockspec structspec {
> +			$1->ast_right = $2;
> +			$2->ast_right = $3;
> +			$$ = $1;
> +		}
> +;
> +get_stmt:	TOK_GET blockspec { $1->ast_right = $2; $$ = $1; }
> +		| TOK_GET blockspec TOK_STATE {
> +			$1->ast_right = $2;
> +			$2->ast_right = $3;
> +			$$ = $1;
> +		}
> +;
> +blockspec:	offset			{ $$ = $1; }
> +		| address		{ $$ = $1; }
> +		| path			{ $$ = $1; }
> +		| block_literal		{ $$ = $1; }
> +		| subscript		{ $$ = $1; }
> +;
> +offset:		blockspec TOK_OFFSET {
> +			$2->ast_left = $1;
> +			$$ = $2;
> +		}
> +;
> +block_literal:	identifier		{ $$ = $1; }
> +;
> +subscript:	block_literal TOK_LBRACKET index TOK_RBRACKET {
> +			$4->ast_left = $1;
> +			$1->ast_left = $3;
> +			$$ = $4;
> +		}
> +;
> +index:		number			{ $$ = $1; }
> +		| identifier		{ $$ = $1; }
> +;
> +address:	number			{ $1->ast_type = AST_EX_ADDRESS; $$ = $1; }
> +;
> +path:		string			{
> +			if (*($1->ast_str) != '/') {
> +				fprintf(stderr, "Path doesn't begin with '/': %s\n", $1->ast_str);
> +				YYABORT;
> +			}
> +			$1->ast_type = AST_EX_PATH;
> +			$$ = $1;
> +		}
> +;
> +structspec:	TOK_LBRACE fieldspecs TOK_RBRACE { $$ = $2; }
> +;
> +fieldspecs:	fieldspecs TOK_COMMA fieldspec	{ $1->ast_left = $3; $$ = $1; }
> +		| fieldspec			{ $$ = $1; }
> +;
> +fieldspec:	identifier TOK_COLON fieldvalue {
> +			$2->ast_right = $1;
> +			$1->ast_right = $3;
> +			$$ = $2;
> +		}
> +;
> +fieldvalue:	number			{ $$ = $1; }
> +		| string		{ $$ = $1; }
> +;
> +number:		TOK_NUMBER		{ $$ = $1; }
> +string:		TOK_STRING		{ $$ = $1; }
> +identifier:	TOK_ID			{ $$ = $1; }
> +%%
> +
> +/**
> + * Allocate and initialize a new parse state structure. The caller must free the
> + * memory returned by this function.
> + */
> +struct lgfs2_lang_state *lgfs2_lang_init(void)
> +{
> +	struct lgfs2_lang_state *state;
> +	state = calloc(1, sizeof(struct lgfs2_lang_state));
> +	if (state == NULL) {
> +		return NULL;
> +	}
> +	state->ls_linenum = 1;
> +	return state;
> +}
> +
> +void lgfs2_lang_free(struct lgfs2_lang_state **state)
> +{
> +	ast_destroy(&(*state)->ls_ast_root);
> +	free(*state);
> +	*state = NULL;
> +}
> +
> +int lgfs2_lang_parsef(struct lgfs2_lang_state *state, FILE *src)
> +{
> +	int ret = 0;
> +	yyscan_t lexer;
> +
> +	ret = yylex_init_extra(state, &lexer);
> +	if (ret != 0) {
> +		fprintf(stderr, "Failed to initialize lexer.\n");
> +		return ret;
> +	}
> +
> +	yyset_in(src, lexer);
> +	ret = yyparse(state, lexer);
> +	yylex_destroy(lexer);
> +	return ret;
> +}
> +
> +int lgfs2_lang_parses(struct lgfs2_lang_state *state, const char *cstr)
> +{
> +	int ret;
> +	FILE *src;
> +	char *str = strdup(cstr);
> +
> +	if (str == NULL) {
> +		perror("Failed to duplicate source string");
> +		return 1;
> +	}
> +	src = fmemopen(str, strlen(str), "r");
> +	if (src == NULL) {
> +		perror("Failed to open string as source file");
> +		free(str);
> +		return 1;
> +	}
> +	ret = lgfs2_lang_parsef(state, src);
> +	fclose(src);
> +	free(str);
> +	if (ret != 0 || state->ls_errnum != 0) {
> +		return 1;
> +	}
> +	return 0;
> +}
> diff --git a/gfs2/libgfs2/super.c b/gfs2/libgfs2/super.c
> index a3c1964..fdf0e60 100644
> --- a/gfs2/libgfs2/super.c
> +++ b/gfs2/libgfs2/super.c
> @@ -25,7 +25,7 @@ int check_sb(struct gfs2_sb *sb)
>  {
>  	if (sb->sb_header.mh_magic != GFS2_MAGIC ||
>  	    sb->sb_header.mh_type != GFS2_METATYPE_SB) {
> -		errno = -EIO;
> +		errno = EIO;
>  		return -1;
>  	}
>  	if (sb->sb_fs_format == GFS_FORMAT_FS &&



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]