summaryrefslogtreecommitdiffstats
path: root/xlators/experimental/fdl
diff options
context:
space:
mode:
Diffstat (limited to 'xlators/experimental/fdl')
-rw-r--r--xlators/experimental/fdl/src/dump-tmpl.c223
-rw-r--r--xlators/experimental/fdl/src/fdl-tmpl.c788
-rw-r--r--xlators/experimental/fdl/src/recon-tmpl.c423
3 files changed, 738 insertions, 696 deletions
diff --git a/xlators/experimental/fdl/src/dump-tmpl.c b/xlators/experimental/fdl/src/dump-tmpl.c
index d19f6589e66..32b0fef6af3 100644
--- a/xlators/experimental/fdl/src/dump-tmpl.c
+++ b/xlators/experimental/fdl/src/dump-tmpl.c
@@ -14,140 +14,150 @@
* Returns 0 if the string is ASCII printable *
* and -1 if it's not ASCII printable *
*/
-int
-str_isprint(char *s)
+int str_isprint (char *s)
{
- int ret = -1;
+ int ret = -1;
- if (!s)
- goto out;
+ if (!s)
+ goto out;
- while (s[0] != '\0') {
- if (!isprint(s[0]))
- goto out;
- else
- s++;
- }
+ while (s[0] != '\0') {
+ if (!isprint(s[0]))
+ goto out;
+ else
+ s++;
+ }
- ret = 0;
+ ret = 0;
out:
- return ret;
+ return ret;
}
#pragma fragment DICT
-{
- int key_len, data_len;
- char *key_ptr;
- char *key_val;
- printf("@ARGNAME@ = dict {\n");
- for (;;) {
- key_len = *((int *)new_meta);
- new_meta += sizeof(int);
- if (!key_len) {
- break;
+ {
+ int key_len, data_len;
+ char *key_ptr;
+ char *key_val;
+ printf ("@ARGNAME@ = dict {\n");
+ for (;;) {
+ key_len = *((int *)new_meta);
+ new_meta += sizeof(int);
+ if (!key_len) {
+ break;
+ }
+ key_ptr = new_meta;
+ new_meta += key_len;
+ data_len = *((int *)new_meta);
+ key_val = new_meta + sizeof(int);
+ new_meta += sizeof(int) + data_len;
+ if (str_isprint(key_val))
+ printf (" %s = <%d bytes>\n",
+ key_ptr, data_len);
+ else
+ printf (" %s = %s <%d bytes>\n",
+ key_ptr, key_val, data_len);
+ }
+ printf ("}\n");
}
- key_ptr = new_meta;
- new_meta += key_len;
- data_len = *((int *)new_meta);
- key_val = new_meta + sizeof(int);
- new_meta += sizeof(int) + data_len;
- if (str_isprint(key_val))
- printf(" %s = <%d bytes>\n", key_ptr, data_len);
- else
- printf(" %s = %s <%d bytes>\n", key_ptr, key_val, data_len);
- }
- printf("}\n");
-}
#pragma fragment DOUBLE
-printf("@ARGNAME@ = @FORMAT@\n", *((uint64_t *)new_meta),
- *((uint64_t *)new_meta));
-new_meta += sizeof(uint64_t);
+ printf ("@ARGNAME@ = @FORMAT@\n", *((uint64_t *)new_meta),
+ *((uint64_t *)new_meta));
+ new_meta += sizeof(uint64_t);
#pragma fragment GFID
-printf("@ARGNAME@ = <gfid %s>\n", uuid_utoa(*((uuid_t *)new_meta)));
-new_meta += 16;
+ printf ("@ARGNAME@ = <gfid %s>\n", uuid_utoa(*((uuid_t *)new_meta)));
+ new_meta += 16;
#pragma fragment INTEGER
-printf("@ARGNAME@ = @FORMAT@\n", *((uint32_t *)new_meta),
- *((uint32_t *)new_meta));
-new_meta += sizeof(uint32_t);
+ printf ("@ARGNAME@ = @FORMAT@\n", *((uint32_t *)new_meta),
+ *((uint32_t *)new_meta));
+ new_meta += sizeof(uint32_t);
#pragma fragment LOC
-printf("@ARGNAME@ = loc {\n");
-printf(" gfid = %s\n", uuid_utoa(*((uuid_t *)new_meta)));
-new_meta += 16;
-printf(" pargfid = %s\n", uuid_utoa(*((uuid_t *)new_meta)));
-new_meta += 16;
-if (*(new_meta++)) {
- printf(" name = %s\n", new_meta);
- new_meta += (strlen(new_meta) + 1);
-}
-printf("}\n");
+ printf ("@ARGNAME@ = loc {\n");
+ printf (" gfid = %s\n", uuid_utoa(*((uuid_t *)new_meta)));
+ new_meta += 16;
+ printf (" pargfid = %s\n", uuid_utoa(*((uuid_t *)new_meta)));
+ new_meta += 16;
+ if (*(new_meta++)) {
+ printf (" name = %s\n", new_meta);
+ new_meta += (strlen(new_meta) + 1);
+ }
+ printf ("}\n");
#pragma fragment STRING
-if (*(new_meta++)) {
- printf("@ARGNAME@ = %s\n", new_meta);
- new_meta += (strlen(new_meta) + 1);
-}
+ if (*(new_meta++)) {
+ printf ("@ARGNAME@ = %s\n", new_meta);
+ new_meta += (strlen(new_meta) + 1);
+ }
#pragma fragment VECTOR
-{
- size_t len = *((size_t *)new_meta);
- new_meta += sizeof(len);
- printf("@ARGNAME@ = <%zu bytes>\n", len);
- new_data += len;
-}
+ {
+ size_t len = *((size_t *)new_meta);
+ new_meta += sizeof(len);
+ printf ("@ARGNAME@ = <%zu bytes>\n", len);
+ new_data += len;
+ }
#pragma fragment IATT
-{
- ia_prot_t *myprot = ((ia_prot_t *)new_meta);
- printf("@ARGNAME@ = iatt {\n");
- printf(" ia_prot = %c%c%c", myprot->suid ? 'S' : '-',
- myprot->sgid ? 'S' : '-', myprot->sticky ? 'T' : '-');
- printf("%c%c%c", myprot->owner.read ? 'r' : '-',
- myprot->owner.write ? 'w' : '-', myprot->owner.exec ? 'x' : '-');
- printf("%c%c%c", myprot->group.read ? 'r' : '-',
- myprot->group.write ? 'w' : '-', myprot->group.exec ? 'x' : '-');
- printf("%c%c%c\n", myprot->other.read ? 'r' : '-',
- myprot->other.write ? 'w' : '-', myprot->other.exec ? 'x' : '-');
- new_meta += sizeof(ia_prot_t);
- uint32_t *myints = (uint32_t *)new_meta;
- printf(" ia_uid = %u\n", myints[0]);
- printf(" ia_gid = %u\n", myints[1]);
- printf(" ia_atime = %u.%09u\n", myints[2], myints[3]);
- printf(" ia_mtime = %u.%09u\n", myints[4], myints[5]);
- new_meta += sizeof(*myints) * 6;
-}
+ {
+ ia_prot_t *myprot = ((ia_prot_t *)new_meta);
+ printf ("@ARGNAME@ = iatt {\n");
+ printf (" ia_prot = %c%c%c",
+ myprot->suid ? 'S' : '-',
+ myprot->sgid ? 'S' : '-',
+ myprot->sticky ? 'T' : '-');
+ printf ("%c%c%c",
+ myprot->owner.read ? 'r' : '-',
+ myprot->owner.write ? 'w' : '-',
+ myprot->owner.exec ? 'x' : '-');
+ printf ("%c%c%c",
+ myprot->group.read ? 'r' : '-',
+ myprot->group.write ? 'w' : '-',
+ myprot->group.exec ? 'x' : '-');
+ printf ("%c%c%c\n",
+ myprot->other.read ? 'r' : '-',
+ myprot->other.write ? 'w' : '-',
+ myprot->other.exec ? 'x' : '-');
+ new_meta += sizeof(ia_prot_t);
+ uint32_t *myints = (uint32_t *)new_meta;
+ printf (" ia_uid = %u\n", myints[0]);
+ printf (" ia_gid = %u\n", myints[1]);
+ printf (" ia_atime = %u.%09u\n", myints[2], myints[3]);
+ printf (" ia_mtime = %u.%09u\n", myints[4], myints[5]);
+ new_meta += sizeof(*myints) * 6;
+ }
#pragma fragment FOP
-void fdl_dump_ @NAME @(char **old_meta, char **old_data)
+void
+fdl_dump_@NAME@ (char **old_meta, char **old_data)
{
- char *new_meta = *old_meta;
- char *new_data = *old_data;
+ char *new_meta = *old_meta;
+ char *new_data = *old_data;
- /* TBD: word size/endianness */
- @FUNCTION_BODY @
+ /* TBD: word size/endianness */
+@FUNCTION_BODY@
*old_meta = new_meta;
- *old_data = new_data;
+ *old_data = new_data;
}
#pragma fragment CASE
-case GF_FOP_ @UPNAME @:
- printf("=== GF_FOP_@UPNAME@\n");
- fdl_dump_ @NAME @(&new_meta, &new_data);
- break;
+ case GF_FOP_@UPNAME@:
+ printf ("=== GF_FOP_@UPNAME@\n");
+ fdl_dump_@NAME@ (&new_meta, &new_data);
+ break;
#pragma fragment EPILOG
- int
- fdl_dump(char **old_meta, char **old_data)
- {
- char *new_meta = *old_meta;
- char *new_data = *old_data;
- static glfs_t *fs = NULL;
- int recognized = 1;
- event_header_t *eh;
+int
+fdl_dump (char **old_meta, char **old_data)
+{
+ char *new_meta = *old_meta;
+ char *new_data = *old_data;
+ static glfs_t *fs = NULL;
+ int recognized = 1;
+ event_header_t *eh;
/*
* We don't really call anything else in GFAPI, but this is the most
@@ -155,22 +165,23 @@ case GF_FOP_ @UPNAME @:
* or glusterfsd initialize (e.g. setting up THIS).
*/
if (!fs) {
- fs = glfs_new("dummy");
+ fs = glfs_new ("dummy");
}
eh = (event_header_t *)new_meta;
- new_meta += sizeof(*eh);
+ new_meta += sizeof (*eh);
/* TBD: check event_type instead of assuming NEW_REQUEST */
switch (eh->fop_type) {
- @SWITCH_BODY @
+@SWITCH_BODY@
- default : printf("unknown fop %u\n", eh->fop_type);
- recognized = 0;
+ default:
+ printf ("unknown fop %u\n", eh->fop_type);
+ recognized = 0;
}
*old_meta = new_meta;
*old_data = new_data;
return recognized;
- }
+}
diff --git a/xlators/experimental/fdl/src/fdl-tmpl.c b/xlators/experimental/fdl/src/fdl-tmpl.c
index 7388b83e0bc..145dad7964a 100644
--- a/xlators/experimental/fdl/src/fdl-tmpl.c
+++ b/xlators/experimental/fdl/src/fdl-tmpl.c
@@ -24,489 +24,513 @@
#include "fdl.h"
/* TBD: make tunable */
-#define META_FILE_SIZE (1 << 20)
-#define DATA_FILE_SIZE (1 << 24)
+#define META_FILE_SIZE (1 << 20)
+#define DATA_FILE_SIZE (1 << 24)
-enum gf_fdl { gf_fdl_mt_fdl_private_t = gf_common_mt_end + 1, gf_fdl_mt_end };
+enum gf_fdl {
+ gf_fdl_mt_fdl_private_t = gf_common_mt_end + 1,
+ gf_fdl_mt_end
+};
typedef struct {
- char *type;
- off_t size;
- char *path;
- int fd;
- void *ptr;
- off_t max_offset;
+ char *type;
+ off_t size;
+ char *path;
+ int fd;
+ void * ptr;
+ off_t max_offset;
} log_obj_t;
typedef struct {
- struct list_head reqs;
- pthread_mutex_t req_lock;
- pthread_cond_t req_cond;
- char *log_dir;
- pthread_t worker;
- gf_boolean_t should_stop;
- gf_boolean_t change_term;
- log_obj_t meta_log;
- log_obj_t data_log;
- int term;
- int first_term;
+ struct list_head reqs;
+ pthread_mutex_t req_lock;
+ pthread_cond_t req_cond;
+ char *log_dir;
+ pthread_t worker;
+ gf_boolean_t should_stop;
+ gf_boolean_t change_term;
+ log_obj_t meta_log;
+ log_obj_t data_log;
+ int term;
+ int first_term;
} fdl_private_t;
int32_t
-fdl_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata);
+fdl_ipc (call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata);
void
-fdl_enqueue(xlator_t *this, call_stub_t *stub)
+fdl_enqueue (xlator_t *this, call_stub_t *stub)
{
- fdl_private_t *priv = this->private;
+ fdl_private_t *priv = this->private;
- pthread_mutex_lock(&priv->req_lock);
- list_add_tail(&stub->list, &priv->reqs);
- pthread_mutex_unlock(&priv->req_lock);
+ pthread_mutex_lock (&priv->req_lock);
+ list_add_tail (&stub->list, &priv->reqs);
+ pthread_mutex_unlock (&priv->req_lock);
- pthread_cond_signal(&priv->req_cond);
+ pthread_cond_signal (&priv->req_cond);
}
#pragma generate
char *
-fdl_open_term_log(xlator_t *this, log_obj_t *obj, int term)
+fdl_open_term_log (xlator_t *this, log_obj_t *obj, int term)
{
- fdl_private_t *priv = this->private;
- int ret;
- char *ptr = NULL;
-
- /*
- * Use .jnl instead of .log so that we don't get test info (mistakenly)
- * appended to our journal files.
- */
- if (this->ctx->cmd_args.log_ident) {
- ret = gf_asprintf(&obj->path, "%s/%s-%s-%d.jnl", priv->log_dir,
- this->ctx->cmd_args.log_ident, obj->type, term);
- } else {
- ret = gf_asprintf(&obj->path, "%s/fubar-%s-%d.jnl", priv->log_dir,
- obj->type, term);
- }
- if ((ret <= 0) || !obj->path) {
- gf_log(this->name, GF_LOG_ERROR, "failed to construct log-file path");
- goto err;
- }
-
- gf_log(this->name, GF_LOG_INFO, "opening %s (size %ld)", obj->path,
- obj->size);
-
- obj->fd = open(obj->path, O_RDWR | O_CREAT | O_TRUNC, 0666);
- if (obj->fd < 0) {
- gf_log(this->name, GF_LOG_ERROR, "failed to open log file (%s)",
- strerror(errno));
- goto err;
- }
+ fdl_private_t *priv = this->private;
+ int ret;
+ char * ptr = NULL;
+
+ /*
+ * Use .jnl instead of .log so that we don't get test info (mistakenly)
+ * appended to our journal files.
+ */
+ if (this->ctx->cmd_args.log_ident) {
+ ret = gf_asprintf (&obj->path, "%s/%s-%s-%d.jnl",
+ priv->log_dir, this->ctx->cmd_args.log_ident,
+ obj->type, term);
+ }
+ else {
+ ret = gf_asprintf (&obj->path, "%s/fubar-%s-%d.jnl",
+ priv->log_dir, obj->type, term);
+ }
+ if ((ret <= 0) || !obj->path) {
+ gf_log (this->name, GF_LOG_ERROR,
+ "failed to construct log-file path");
+ goto err;
+ }
+
+ gf_log (this->name, GF_LOG_INFO, "opening %s (size %ld)",
+ obj->path, obj->size);
+
+ obj->fd = open (obj->path, O_RDWR|O_CREAT|O_TRUNC, 0666);
+ if (obj->fd < 0) {
+ gf_log (this->name, GF_LOG_ERROR,
+ "failed to open log file (%s)", strerror(errno));
+ goto err;
+ }
#if !defined(GF_BSD_HOST_OS)
- /*
- * NetBSD can just go die in a fire. Even though it claims to support
- * fallocate/posix_fallocate they don't actually *do* anything so the
- * file size remains zero. Then mmap succeeds anyway, but any access
- * to the mmap'ed region will segfault. It would be acceptable for
- * fallocate to do what it says, for mmap to fail, or for access to
- * extend the file. NetBSD managed to hit the trifecta of Getting
- * Everything Wrong, and debugging in that environment to get this far
- * has already been painful enough (systems I worked on in 1990 were
- * better that way). We'll fall through to the lseek/write method, and
- * performance will be worse, and TOO BAD.
- */
- if (sys_fallocate(obj->fd, 0, 0, obj->size) < 0)
+ /*
+ * NetBSD can just go die in a fire. Even though it claims to support
+ * fallocate/posix_fallocate they don't actually *do* anything so the
+ * file size remains zero. Then mmap succeeds anyway, but any access
+ * to the mmap'ed region will segfault. It would be acceptable for
+ * fallocate to do what it says, for mmap to fail, or for access to
+ * extend the file. NetBSD managed to hit the trifecta of Getting
+ * Everything Wrong, and debugging in that environment to get this far
+ * has already been painful enough (systems I worked on in 1990 were
+ * better that way). We'll fall through to the lseek/write method, and
+ * performance will be worse, and TOO BAD.
+ */
+ if (sys_fallocate(obj->fd,0,0,obj->size) < 0)
#endif
- {
- gf_log(this->name, GF_LOG_WARNING,
- "failed to fallocate space for log file");
- /* Have to do this the ugly page-faulty way. */
- (void)sys_lseek(obj->fd, obj->size - 1, SEEK_SET);
- (void)sys_write(obj->fd, "", 1);
- }
-
- ptr = mmap(NULL, obj->size, PROT_WRITE, MAP_SHARED, obj->fd, 0);
- if (ptr == MAP_FAILED) {
- gf_log(this->name, GF_LOG_ERROR, "failed to mmap log (%s)",
- strerror(errno));
- goto err;
- }
-
- obj->ptr = ptr;
- obj->max_offset = 0;
- return ptr;
+ {
+ gf_log (this->name, GF_LOG_WARNING,
+ "failed to fallocate space for log file");
+ /* Have to do this the ugly page-faulty way. */
+ (void) sys_lseek (obj->fd, obj->size-1, SEEK_SET);
+ (void) sys_write (obj->fd, "", 1);
+ }
+
+ ptr = mmap (NULL, obj->size, PROT_WRITE, MAP_SHARED, obj->fd, 0);
+ if (ptr == MAP_FAILED) {
+ gf_log (this->name, GF_LOG_ERROR, "failed to mmap log (%s)",
+ strerror(errno));
+ goto err;
+ }
+
+ obj->ptr = ptr;
+ obj->max_offset = 0;
+ return ptr;
err:
- if (obj->fd >= 0) {
- sys_close(obj->fd);
- obj->fd = (-1);
- }
- if (obj->path) {
- GF_FREE(obj->path);
- obj->path = NULL;
- }
- return ptr;
+ if (obj->fd >= 0) {
+ sys_close (obj->fd);
+ obj->fd = (-1);
+ }
+ if (obj->path) {
+ GF_FREE (obj->path);
+ obj->path = NULL;
+ }
+ return ptr;
}
void
-fdl_close_term_log(xlator_t *this, log_obj_t *obj)
+fdl_close_term_log (xlator_t *this, log_obj_t *obj)
{
- fdl_private_t *priv = this->private;
-
- if (obj->ptr) {
- (void)munmap(obj->ptr, obj->size);
- obj->ptr = NULL;
- }
-
- if (obj->fd >= 0) {
- gf_log(this->name, GF_LOG_INFO, "truncating term %d %s journal to %ld",
- priv->term, obj->type, obj->max_offset);
- if (sys_ftruncate(obj->fd, obj->max_offset) < 0) {
- gf_log(this->name, GF_LOG_WARNING,
- "failed to truncate journal (%s)", strerror(errno));
+ fdl_private_t *priv = this->private;
+
+ if (obj->ptr) {
+ (void) munmap (obj->ptr, obj->size);
+ obj->ptr = NULL;
+ }
+
+ if (obj->fd >= 0) {
+ gf_log (this->name, GF_LOG_INFO,
+ "truncating term %d %s journal to %ld",
+ priv->term, obj->type, obj->max_offset);
+ if (sys_ftruncate(obj->fd,obj->max_offset) < 0) {
+ gf_log (this->name, GF_LOG_WARNING,
+ "failed to truncate journal (%s)",
+ strerror(errno));
+ }
+ sys_close (obj->fd);
+ obj->fd = (-1);
+ }
+
+ if (obj->path) {
+ GF_FREE (obj->path);
+ obj->path = NULL;
}
- sys_close(obj->fd);
- obj->fd = (-1);
- }
-
- if (obj->path) {
- GF_FREE(obj->path);
- obj->path = NULL;
- }
}
gf_boolean_t
-fdl_change_term(xlator_t *this, char **meta_ptr, char **data_ptr)
+fdl_change_term (xlator_t *this, char **meta_ptr, char **data_ptr)
{
- fdl_private_t *priv = this->private;
+ fdl_private_t *priv = this->private;
- fdl_close_term_log(this, &priv->meta_log);
- fdl_close_term_log(this, &priv->data_log);
+ fdl_close_term_log (this, &priv->meta_log);
+ fdl_close_term_log (this, &priv->data_log);
- ++(priv->term);
+ ++(priv->term);
- *meta_ptr = fdl_open_term_log(this, &priv->meta_log, priv->term);
- if (!*meta_ptr) {
- return _gf_false;
- }
+ *meta_ptr = fdl_open_term_log (this, &priv->meta_log, priv->term);
+ if (!*meta_ptr) {
+ return _gf_false;
+ }
- *data_ptr = fdl_open_term_log(this, &priv->data_log, priv->term);
- if (!*data_ptr) {
- return _gf_false;
- }
+ *data_ptr = fdl_open_term_log (this, &priv->data_log, priv->term);
+ if (!*data_ptr) {
+ return _gf_false;
+ }
- return _gf_true;
+ return _gf_true;
}
void *
-fdl_worker(void *arg)
+fdl_worker (void *arg)
{
- xlator_t *this = arg;
- fdl_private_t *priv = this->private;
- call_stub_t *stub;
- char *meta_ptr = NULL;
- off_t *meta_offset = &priv->meta_log.max_offset;
- char *data_ptr = NULL;
- off_t *data_offset = &priv->data_log.max_offset;
- unsigned long base_as_ul;
- void *msync_ptr;
- size_t msync_len;
- gf_boolean_t recycle;
- void *err_label = &&err_unlocked;
-
- priv->meta_log.type = "meta";
- priv->meta_log.size = META_FILE_SIZE;
- priv->meta_log.path = NULL;
- priv->meta_log.fd = (-1);
- priv->meta_log.ptr = NULL;
-
- priv->data_log.type = "data";
- priv->data_log.size = DATA_FILE_SIZE;
- priv->data_log.path = NULL;
- priv->data_log.fd = (-1);
- priv->data_log.ptr = NULL;
-
- /* TBD: initial term should come from persistent storage (e.g. etcd) */
- priv->first_term = ++(priv->term);
- meta_ptr = fdl_open_term_log(this, &priv->meta_log, priv->term);
- if (!meta_ptr) {
- goto *err_label;
- }
- data_ptr = fdl_open_term_log(this, &priv->data_log, priv->term);
- if (!data_ptr) {
- fdl_close_term_log(this, &priv->meta_log);
- goto *err_label;
- }
-
- for (;;) {
- pthread_mutex_lock(&priv->req_lock);
- err_label = &&err_locked;
- while (list_empty(&priv->reqs)) {
- pthread_cond_wait(&priv->req_cond, &priv->req_lock);
- if (priv->should_stop) {
+ xlator_t *this = arg;
+ fdl_private_t *priv = this->private;
+ call_stub_t *stub;
+ char * meta_ptr = NULL;
+ off_t *meta_offset = &priv->meta_log.max_offset;
+ char * data_ptr = NULL;
+ off_t *data_offset = &priv->data_log.max_offset;
+ unsigned long base_as_ul;
+ void * msync_ptr;
+ size_t msync_len;
+ gf_boolean_t recycle;
+ void *err_label = &&err_unlocked;
+
+ priv->meta_log.type = "meta";
+ priv->meta_log.size = META_FILE_SIZE;
+ priv->meta_log.path = NULL;
+ priv->meta_log.fd = (-1);
+ priv->meta_log.ptr = NULL;
+
+ priv->data_log.type = "data";
+ priv->data_log.size = DATA_FILE_SIZE;
+ priv->data_log.path = NULL;
+ priv->data_log.fd = (-1);
+ priv->data_log.ptr = NULL;
+
+ /* TBD: initial term should come from persistent storage (e.g. etcd) */
+ priv->first_term = ++(priv->term);
+ meta_ptr = fdl_open_term_log (this, &priv->meta_log, priv->term);
+ if (!meta_ptr) {
goto *err_label;
- }
- if (priv->change_term) {
- if (!fdl_change_term(this, &meta_ptr, &data_ptr)) {
- goto *err_label;
- }
- priv->change_term = _gf_false;
- continue;
- }
- }
- stub = list_entry(priv->reqs.next, call_stub_t, list);
- list_del_init(&stub->list);
- pthread_mutex_unlock(&priv->req_lock);
- err_label = &&err_unlocked;
- /*
- * TBD: batch requests
- *
- * What we should do here is gather up *all* of the requests
- * that have accumulated since we were last at this point,
- * blast them all out in one big writev, and then dispatch them
- * all before coming back for more. That maximizes throughput,
- * at some cost to latency (due to queuing effects at the log
- * stage). Note that we're likely to be above io-threads, so
- * the dispatch itself will be parallelized (at further cost to
- * latency). For now, we just do the simplest thing and handle
- * one request all the way through before fetching the next.
- *
- * So, why mmap/msync instead of writev/fdatasync? Because it's
- * faster. Much faster. So much faster that I half-suspect
- * cheating, but it's more convenient for now than having to
- * ensure that everything's page-aligned for O_DIRECT (the only
- * alternative that still might avoid ridiculous levels of
- * local-FS overhead).
- *
- * TBD: check that msync really does get our data to disk.
- */
- gf_log(this->name, GF_LOG_DEBUG, "logging %u+%u bytes for op %d",
- stub->jnl_meta_len, stub->jnl_data_len, stub->fop);
- recycle = _gf_false;
- if ((*meta_offset + stub->jnl_meta_len) > priv->meta_log.size) {
- recycle = _gf_true;
}
- if ((*data_offset + stub->jnl_data_len) > priv->data_log.size) {
- recycle = _gf_true;
- }
- if (recycle && !fdl_change_term(this, &meta_ptr, &data_ptr)) {
- goto *err_label;
- }
- meta_ptr = priv->meta_log.ptr;
- data_ptr = priv->data_log.ptr;
- gf_log(this->name, GF_LOG_DEBUG, "serializing to %p/%p",
- meta_ptr + *meta_offset, data_ptr + *data_offset);
- stub->serialize(stub, meta_ptr + *meta_offset, data_ptr + *data_offset);
- if (stub->jnl_meta_len > 0) {
- base_as_ul = (unsigned long)(meta_ptr + *meta_offset);
- msync_ptr = (void *)(base_as_ul & ~0x0fff);
- msync_len = (size_t)(base_as_ul & 0x0fff);
- if (msync(msync_ptr, msync_len + stub->jnl_meta_len, MS_SYNC) < 0) {
- gf_log(this->name, GF_LOG_WARNING,
- "failed to log request meta (%s)", strerror(errno));
- }
- *meta_offset += stub->jnl_meta_len;
+ data_ptr = fdl_open_term_log (this, &priv->data_log, priv->term);
+ if (!data_ptr) {
+ fdl_close_term_log (this, &priv->meta_log);
+ goto *err_label;
}
- if (stub->jnl_data_len > 0) {
- base_as_ul = (unsigned long)(data_ptr + *data_offset);
- msync_ptr = (void *)(base_as_ul & ~0x0fff);
- msync_len = (size_t)(base_as_ul & 0x0fff);
- if (msync(msync_ptr, msync_len + stub->jnl_data_len, MS_SYNC) < 0) {
- gf_log(this->name, GF_LOG_WARNING,
- "failed to log request data (%s)", strerror(errno));
- }
- *data_offset += stub->jnl_data_len;
+
+ for (;;) {
+ pthread_mutex_lock (&priv->req_lock);
+ err_label = &&err_locked;
+ while (list_empty(&priv->reqs)) {
+ pthread_cond_wait (&priv->req_cond, &priv->req_lock);
+ if (priv->should_stop) {
+ goto *err_label;
+ }
+ if (priv->change_term) {
+ if (!fdl_change_term(this, &meta_ptr,
+ &data_ptr)) {
+ goto *err_label;
+ }
+ priv->change_term = _gf_false;
+ continue;
+ }
+ }
+ stub = list_entry (priv->reqs.next, call_stub_t, list);
+ list_del_init (&stub->list);
+ pthread_mutex_unlock (&priv->req_lock);
+ err_label = &&err_unlocked;
+ /*
+ * TBD: batch requests
+ *
+ * What we should do here is gather up *all* of the requests
+ * that have accumulated since we were last at this point,
+ * blast them all out in one big writev, and then dispatch them
+ * all before coming back for more. That maximizes throughput,
+ * at some cost to latency (due to queuing effects at the log
+ * stage). Note that we're likely to be above io-threads, so
+ * the dispatch itself will be parallelized (at further cost to
+ * latency). For now, we just do the simplest thing and handle
+ * one request all the way through before fetching the next.
+ *
+ * So, why mmap/msync instead of writev/fdatasync? Because it's
+ * faster. Much faster. So much faster that I half-suspect
+ * cheating, but it's more convenient for now than having to
+ * ensure that everything's page-aligned for O_DIRECT (the only
+ * alternative that still might avoid ridiculous levels of
+ * local-FS overhead).
+ *
+ * TBD: check that msync really does get our data to disk.
+ */
+ gf_log (this->name, GF_LOG_DEBUG,
+ "logging %u+%u bytes for op %d",
+ stub->jnl_meta_len, stub->jnl_data_len, stub->fop);
+ recycle = _gf_false;
+ if ((*meta_offset + stub->jnl_meta_len) > priv->meta_log.size) {
+ recycle = _gf_true;
+ }
+ if ((*data_offset + stub->jnl_data_len) > priv->data_log.size) {
+ recycle = _gf_true;
+ }
+ if (recycle && !fdl_change_term(this,&meta_ptr,&data_ptr)) {
+ goto *err_label;
+ }
+ meta_ptr = priv->meta_log.ptr;
+ data_ptr = priv->data_log.ptr;
+ gf_log (this->name, GF_LOG_DEBUG, "serializing to %p/%p",
+ meta_ptr + *meta_offset, data_ptr + *data_offset);
+ stub->serialize (stub, meta_ptr + *meta_offset,
+ data_ptr + *data_offset);
+ if (stub->jnl_meta_len > 0) {
+ base_as_ul = (unsigned long) (meta_ptr + *meta_offset);
+ msync_ptr = (void *) (base_as_ul & ~0x0fff);
+ msync_len = (size_t) (base_as_ul & 0x0fff);
+ if (msync (msync_ptr, msync_len+stub->jnl_meta_len,
+ MS_SYNC) < 0) {
+ gf_log (this->name, GF_LOG_WARNING,
+ "failed to log request meta (%s)",
+ strerror(errno));
+ }
+ *meta_offset += stub->jnl_meta_len;
+ }
+ if (stub->jnl_data_len > 0) {
+ base_as_ul = (unsigned long) (data_ptr + *data_offset);
+ msync_ptr = (void *) (base_as_ul & ~0x0fff);
+ msync_len = (size_t) (base_as_ul & 0x0fff);
+ if (msync (msync_ptr, msync_len+stub->jnl_data_len,
+ MS_SYNC) < 0) {
+ gf_log (this->name, GF_LOG_WARNING,
+ "failed to log request data (%s)",
+ strerror(errno));
+ }
+ *data_offset += stub->jnl_data_len;
+ }
+ call_resume (stub);
}
- call_resume(stub);
- }
err_locked:
- pthread_mutex_unlock(&priv->req_lock);
+ pthread_mutex_unlock (&priv->req_lock);
err_unlocked:
- fdl_close_term_log(this, &priv->meta_log);
- fdl_close_term_log(this, &priv->data_log);
- return NULL;
+ fdl_close_term_log (this, &priv->meta_log);
+ fdl_close_term_log (this, &priv->data_log);
+ return NULL;
}
int32_t
-fdl_ipc_continue(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
+fdl_ipc_continue (call_frame_t *frame, xlator_t *this,
+ int32_t op, dict_t *xdata)
{
- /*
- * Nothing to be done here. Just Unwind. *
- */
- STACK_UNWIND_STRICT(ipc, frame, 0, 0, xdata);
+ /*
+ * Nothing to be done here. Just Unwind. *
+ */
+ STACK_UNWIND_STRICT (ipc, frame, 0, 0, xdata);
- return 0;
+ return 0;
}
int32_t
-fdl_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
+fdl_ipc (call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
{
- call_stub_t *stub;
- fdl_private_t *priv = this->private;
- dict_t *tdict;
- int32_t gt_err = EIO;
+ call_stub_t *stub;
+ fdl_private_t *priv = this->private;
+ dict_t *tdict;
+ int32_t gt_err = EIO;
+
+ switch (op) {
- switch (op) {
case FDL_IPC_CHANGE_TERM:
- gf_log(this->name, GF_LOG_INFO, "got CHANGE_TERM op");
- priv->change_term = _gf_true;
- pthread_cond_signal(&priv->req_cond);
- STACK_UNWIND_STRICT(ipc, frame, 0, 0, NULL);
- break;
+ gf_log (this->name, GF_LOG_INFO, "got CHANGE_TERM op");
+ priv->change_term = _gf_true;
+ pthread_cond_signal (&priv->req_cond);
+ STACK_UNWIND_STRICT (ipc, frame, 0, 0, NULL);
+ break;
case FDL_IPC_GET_TERMS:
- gf_log(this->name, GF_LOG_INFO, "got GET_TERMS op");
- tdict = dict_new();
- if (!tdict) {
- gt_err = ENOMEM;
- goto gt_done;
- }
- if (dict_set_int32(tdict, "first", priv->first_term) != 0) {
- goto gt_done;
- }
- if (dict_set_int32(tdict, "last", priv->term) != 0) {
- goto gt_done;
- }
- gt_err = 0;
+ gf_log (this->name, GF_LOG_INFO, "got GET_TERMS op");
+ tdict = dict_new ();
+ if (!tdict) {
+ gt_err = ENOMEM;
+ goto gt_done;
+ }
+ if (dict_set_int32(tdict,"first",priv->first_term) != 0) {
+ goto gt_done;
+ }
+ if (dict_set_int32(tdict,"last",priv->term) != 0) {
+ goto gt_done;
+ }
+ gt_err = 0;
gt_done:
- if (gt_err) {
- STACK_UNWIND_STRICT(ipc, frame, -1, gt_err, NULL);
- } else {
- STACK_UNWIND_STRICT(ipc, frame, 0, 0, tdict);
- }
- if (tdict) {
- dict_unref(tdict);
- }
- break;
+ if (gt_err) {
+ STACK_UNWIND_STRICT (ipc, frame, -1, gt_err, NULL);
+ } else {
+ STACK_UNWIND_STRICT (ipc, frame, 0, 0, tdict);
+ }
+ if (tdict) {
+ dict_unref (tdict);
+ }
+ break;
case FDL_IPC_JBR_SERVER_ROLLBACK:
- /*
- * In case of a rollback from jbr-server, dump *
- * the term and index number in the journal, *
- * which will later be used to rollback the fop *
- */
- stub = fop_ipc_stub(frame, fdl_ipc_continue, op, xdata);
- fdl_len_ipc(stub);
- stub->serialize = fdl_serialize_ipc;
- fdl_enqueue(this, stub);
-
- break;
+ /*
+ * In case of a rollback from jbr-server, dump *
+ * the term and index number in the journal, *
+ * which will later be used to rollback the fop *
+ */
+ stub = fop_ipc_stub (frame, fdl_ipc_continue,
+ op, xdata);
+ fdl_len_ipc (stub);
+ stub->serialize = fdl_serialize_ipc;
+ fdl_enqueue (this, stub);
+
+ break;
default:
- STACK_WIND_TAIL(frame, FIRST_CHILD(this),
- FIRST_CHILD(this)->fops->ipc, op, xdata);
- }
+ STACK_WIND_TAIL (frame,
+ FIRST_CHILD(this),
+ FIRST_CHILD(this)->fops->ipc,
+ op, xdata);
+ }
- return 0;
+ return 0;
}
int
-fdl_init(xlator_t *this)
+fdl_init (xlator_t *this)
{
- fdl_private_t *priv = NULL;
-
- priv = GF_CALLOC(1, sizeof(*priv), gf_fdl_mt_fdl_private_t);
- if (!priv) {
- gf_log(this->name, GF_LOG_ERROR, "failed to allocate fdl_private");
- goto err;
- }
-
- INIT_LIST_HEAD(&priv->reqs);
- if (pthread_mutex_init(&priv->req_lock, NULL) != 0) {
- gf_log(this->name, GF_LOG_ERROR, "failed to initialize req_lock");
- goto err;
- }
- if (pthread_cond_init(&priv->req_cond, NULL) != 0) {
- gf_log(this->name, GF_LOG_ERROR, "failed to initialize req_cond");
- goto err;
- }
-
- GF_OPTION_INIT("log-path", priv->log_dir, path, err);
-
- this->private = priv;
- /*
- * The rest of the fop table is automatically generated, so this is a
- * bit cleaner than messing with the generation to add a hand-written
- * exception.
- */
-
- if (gf_thread_create(&priv->worker, NULL, fdl_worker, this, "fdlwrker") !=
- 0) {
- gf_log(this->name, GF_LOG_ERROR, "failed to start fdl_worker");
- goto err;
- }
-
- return 0;
+ fdl_private_t *priv = NULL;
+
+ priv = GF_CALLOC (1, sizeof (*priv), gf_fdl_mt_fdl_private_t);
+ if (!priv) {
+ gf_log (this->name, GF_LOG_ERROR,
+ "failed to allocate fdl_private");
+ goto err;
+ }
+
+ INIT_LIST_HEAD (&priv->reqs);
+ if (pthread_mutex_init (&priv->req_lock, NULL) != 0) {
+ gf_log (this->name, GF_LOG_ERROR,
+ "failed to initialize req_lock");
+ goto err;
+ }
+ if (pthread_cond_init (&priv->req_cond, NULL) != 0) {
+ gf_log (this->name, GF_LOG_ERROR,
+ "failed to initialize req_cond");
+ goto err;
+ }
+
+ GF_OPTION_INIT ("log-path", priv->log_dir, path, err);
+
+ this->private = priv;
+ /*
+ * The rest of the fop table is automatically generated, so this is a
+ * bit cleaner than messing with the generation to add a hand-written
+ * exception.
+ */
+
+ if (gf_thread_create (&priv->worker, NULL, fdl_worker, this,
+ "fdlwrker") != 0) {
+ gf_log (this->name, GF_LOG_ERROR,
+ "failed to start fdl_worker");
+ goto err;
+ }
+
+ return 0;
err:
- if (priv) {
- GF_FREE(priv);
- }
- return -1;
+ if (priv) {
+ GF_FREE(priv);
+ }
+ return -1;
}
void
-fdl_fini(xlator_t *this)
+fdl_fini (xlator_t *this)
{
- fdl_private_t *priv = this->private;
-
- if (priv) {
- priv->should_stop = _gf_true;
- pthread_cond_signal(&priv->req_cond);
- pthread_join(priv->worker, NULL);
- GF_FREE(priv);
- }
+ fdl_private_t *priv = this->private;
+
+ if (priv) {
+ priv->should_stop = _gf_true;
+ pthread_cond_signal (&priv->req_cond);
+ pthread_join (priv->worker, NULL);
+ GF_FREE(priv);
+ }
}
int
-fdl_reconfigure(xlator_t *this, dict_t *options)
+fdl_reconfigure (xlator_t *this, dict_t *options)
{
- fdl_private_t *priv = this->private;
+ fdl_private_t *priv = this->private;
- GF_OPTION_RECONF("log_dir", priv->log_dir, options, path, out);
- /* TBD: react if it changed */
+ GF_OPTION_RECONF ("log_dir", priv->log_dir, options, path, out);
+ /* TBD: react if it changed */
out:
- return 0;
+ return 0;
}
int32_t
-mem_acct_init(xlator_t *this)
+mem_acct_init (xlator_t *this)
{
- int ret = -1;
+ int ret = -1;
- GF_VALIDATE_OR_GOTO("fdl", this, out);
+ GF_VALIDATE_OR_GOTO ("fdl", this, out);
- ret = xlator_mem_acct_init(this, gf_fdl_mt_end + 1);
+ ret = xlator_mem_acct_init (this, gf_fdl_mt_end + 1);
- if (ret != 0) {
- gf_log(this->name, GF_LOG_ERROR,
- "Memory accounting init"
- "failed");
- return ret;
- }
+ if (ret != 0) {
+ gf_log (this->name, GF_LOG_ERROR, "Memory accounting init"
+ "failed");
+ return ret;
+ }
out:
- return ret;
+ return ret;
}
class_methods_t class_methods = {
- .init = fdl_init,
- .fini = fdl_fini,
- .reconfigure = fdl_reconfigure,
- .notify = default_notify,
+ .init = fdl_init,
+ .fini = fdl_fini,
+ .reconfigure = fdl_reconfigure,
+ .notify = default_notify,
};
struct volume_options options[] = {
- {.key = {"log-path"},
- .type = GF_OPTION_TYPE_PATH,
- .default_value = DEFAULT_LOG_FILE_DIRECTORY,
- .description = "Directory for FDL files."},
- {.key = {NULL}},
+ { .key = {"log-path"},
+ .type = GF_OPTION_TYPE_PATH,
+ .default_value = DEFAULT_LOG_FILE_DIRECTORY,
+ .description = "Directory for FDL files."
+ },
+ { .key = {NULL} },
};
struct xlator_cbks cbks = {
- .release = default_release,
- .releasedir = default_releasedir,
- .forget = default_forget,
+ .release = default_release,
+ .releasedir = default_releasedir,
+ .forget = default_forget,
};
diff --git a/xlators/experimental/fdl/src/recon-tmpl.c b/xlators/experimental/fdl/src/recon-tmpl.c
index 4760eaad2e2..228860401ae 100644
--- a/xlators/experimental/fdl/src/recon-tmpl.c
+++ b/xlators/experimental/fdl/src/recon-tmpl.c
@@ -15,283 +15,290 @@
#define GFAPI_SUCCESS 0
inode_t *
-recon_get_inode(glfs_t *fs, uuid_t gfid)
+recon_get_inode (glfs_t *fs, uuid_t gfid)
{
- inode_t *inode;
- loc_t loc = {
- NULL,
- };
- struct iatt iatt;
- int ret;
- inode_t *newinode;
-
- inode = inode_find(fs->active_subvol->itable, gfid);
- if (inode) {
- printf("=== FOUND %s IN TABLE\n", uuid_utoa(gfid));
- return inode;
- }
-
- loc.inode = inode_new(fs->active_subvol->itable);
- if (!loc.inode) {
- return NULL;
- }
- gf_uuid_copy(loc.inode->gfid, gfid);
- gf_uuid_copy(loc.gfid, gfid);
-
- printf("=== DOING LOOKUP FOR %s\n", uuid_utoa(gfid));
-
- ret = syncop_lookup(fs->active_subvol, &loc, &iatt, NULL, NULL, NULL);
- if (ret != GFAPI_SUCCESS) {
- fprintf(stderr, "syncop_lookup failed (%d)\n", ret);
- return NULL;
- }
-
- newinode = inode_link(loc.inode, NULL, NULL, &iatt);
- if (newinode) {
- inode_lookup(newinode);
- }
-
- return newinode;
-}
+ inode_t *inode;
+ loc_t loc = {NULL,};
+ struct iatt iatt;
+ int ret;
+ inode_t *newinode;
+
+ inode = inode_find (fs->active_subvol->itable, gfid);
+ if (inode) {
+ printf ("=== FOUND %s IN TABLE\n", uuid_utoa(gfid));
+ return inode;
+ }
-#pragma fragment DICT
-dict_t *@ARGNAME @;
+ loc.inode = inode_new (fs->active_subvol->itable);
+ if (!loc.inode) {
+ return NULL;
+ }
+ gf_uuid_copy (loc.inode->gfid, gfid);
+ gf_uuid_copy (loc.gfid, gfid);
-@ARGNAME @ = dict_new();
-if (!@ARGNAME @) {
- goto *err_label;
-}
-err_label = &&cleanup_ @ARGNAME @;
+ printf ("=== DOING LOOKUP FOR %s\n", uuid_utoa(gfid));
-{
- int key_len, data_len;
- char *key_ptr;
- int garbage;
- for (;;) {
- key_len = *((int *)new_meta);
- new_meta += sizeof(int);
- if (!key_len) {
- break;
+ ret = syncop_lookup (fs->active_subvol, &loc, &iatt,
+ NULL, NULL, NULL);
+ if (ret != GFAPI_SUCCESS) {
+ fprintf (stderr, "syncop_lookup failed (%d)\n", ret);
+ return NULL;
}
- key_ptr = new_meta;
- new_meta += key_len;
- data_len = *((int *)new_meta);
- new_meta += sizeof(int);
- garbage = dict_set_static_bin(@ARGNAME @, key_ptr, new_meta, data_len);
- /* TBD: check error from dict_set_static_bin */
- (void)garbage;
- new_meta += data_len;
- }
+
+ newinode = inode_link (loc.inode, NULL, NULL, &iatt);
+ if (newinode) {
+ inode_lookup (newinode);
+ }
+
+ return newinode;
}
+#pragma fragment DICT
+ dict_t *@ARGNAME@;
+
+ @ARGNAME@ = dict_new();
+ if (!@ARGNAME@) {
+ goto *err_label;
+ }
+ err_label = &&cleanup_@ARGNAME@;
+
+ {
+ int key_len, data_len;
+ char *key_ptr;
+ int garbage;
+ for (;;) {
+ key_len = *((int *)new_meta);
+ new_meta += sizeof(int);
+ if (!key_len) {
+ break;
+ }
+ key_ptr = new_meta;
+ new_meta += key_len;
+ data_len = *((int *)new_meta);
+ new_meta += sizeof(int);
+ garbage = dict_set_static_bin (@ARGNAME@, key_ptr,
+ new_meta, data_len);
+ /* TBD: check error from dict_set_static_bin */
+ (void)garbage;
+ new_meta += data_len;
+ }
+ }
+
#pragma fragment DICT_CLEANUP
-cleanup_ @ARGNAME @ : dict_unref(@ARGNAME @);
+cleanup_@ARGNAME@:
+ dict_unref (@ARGNAME@);
#pragma fragment DOUBLE
-@ARGTYPE @ @ARGNAME @ = *((@ARGTYPE @ *)new_meta);
-new_meta += sizeof(uint64_t);
+ @ARGTYPE@ @ARGNAME@ = *((@ARGTYPE@ *)new_meta);
+ new_meta += sizeof(uint64_t);
#pragma fragment FD
-inode_t *@ARGNAME @_ino;
-fd_t *@ARGNAME @;
+ inode_t *@ARGNAME@_ino;
+ fd_t *@ARGNAME@;
-@ARGNAME @_ino = recon_get_inode(fs, *((uuid_t *)new_meta));
-new_meta += 16;
-if (!@ARGNAME @_ino) {
- goto *err_label;
-}
-err_label = &&cleanup_ @ARGNAME @_ino;
+ @ARGNAME@_ino = recon_get_inode (fs, *((uuid_t *)new_meta));
+ new_meta += 16;
+ if (!@ARGNAME@_ino) {
+ goto *err_label;
+ }
+ err_label = &&cleanup_@ARGNAME@_ino;
-@ARGNAME @ = fd_anonymous(@ARGNAME @_ino);
-if (!@ARGNAME @) {
- goto *err_label;
-}
-err_label = &&cleanup_ @ARGNAME @;
+ @ARGNAME@ = fd_anonymous (@ARGNAME@_ino);
+ if (!@ARGNAME@) {
+ goto *err_label;
+ }
+ err_label = &&cleanup_@ARGNAME@;
#pragma fragment FD_CLEANUP
-cleanup_ @ARGNAME @ : fd_unref(@ARGNAME @);
-cleanup_ @ARGNAME @_ino : inode_unref(@ARGNAME @_ino);
+cleanup_@ARGNAME@:
+ fd_unref (@ARGNAME@);
+cleanup_@ARGNAME@_ino:
+ inode_unref (@ARGNAME@_ino);
#pragma fragment NEW_FD
-/*
- * This pseudo-type is only used for create, and in that case we know
- * we'll be using loc.inode, so it's not worth generalizing to take an
- * extra argument.
- */
-fd_t *@ARGNAME @ = fd_anonymous(loc.inode);
-
-if (!fd) {
- goto *err_label;
-}
-err_label = &&cleanup_ @ARGNAME @;
-new_meta += 16;
+ /*
+ * This pseudo-type is only used for create, and in that case we know
+ * we'll be using loc.inode, so it's not worth generalizing to take an
+ * extra argument.
+ */
+ fd_t *@ARGNAME@ = fd_anonymous (loc.inode);
+
+ if (!fd) {
+ goto *err_label;
+ }
+ err_label = &&cleanup_@ARGNAME@;
+ new_meta += 16;
#pragma fragment NEW_FD_CLEANUP
-cleanup_ @ARGNAME @ : fd_unref(@ARGNAME @);
+cleanup_@ARGNAME@:
+ fd_unref (@ARGNAME@);
#pragma fragment INTEGER
-@ARGTYPE @ @ARGNAME @ = *((@ARGTYPE @ *)new_meta);
+ @ARGTYPE@ @ARGNAME@ = *((@ARGTYPE@ *)new_meta);
-new_meta += sizeof(@ARGTYPE @);
+ new_meta += sizeof(@ARGTYPE@);
#pragma fragment LOC
-loc_t @ARGNAME @ = {
- NULL,
-};
+ loc_t @ARGNAME@ = { NULL, };
-@ARGNAME @.inode = recon_get_inode(fs, *((uuid_t *)new_meta));
-if (!@ARGNAME @.inode) {
- goto *err_label;
-}
-err_label = &&cleanup_ @ARGNAME @;
-gf_uuid_copy(@ARGNAME @.gfid, @ARGNAME @.inode->gfid);
-new_meta += 16;
-new_meta += 16; /* skip over pargfid */
-if (*(new_meta++)) {
- @ARGNAME @.name = new_meta;
- new_meta += strlen(new_meta) + 1;
-}
+ @ARGNAME@.inode = recon_get_inode (fs, *((uuid_t *)new_meta));
+ if (!@ARGNAME@.inode) {
+ goto *err_label;
+ }
+ err_label = &&cleanup_@ARGNAME@;
+ gf_uuid_copy (@ARGNAME@.gfid, @ARGNAME@.inode->gfid);
+ new_meta += 16;
+ new_meta += 16; /* skip over pargfid */
+ if (*(new_meta++)) {
+ @ARGNAME@.name = new_meta;
+ new_meta += strlen(new_meta) + 1;
+ }
#pragma fragment LOC_CLEANUP
-cleanup_ @ARGNAME @ : loc_wipe(&@ARGNAME @);
+cleanup_@ARGNAME@:
+ loc_wipe (&@ARGNAME@);
#pragma fragment PARENT_LOC
-loc_t @ARGNAME @ = {
- NULL,
-};
-
-new_meta += 16; /* skip over gfid */
-@ARGNAME @.parent = recon_get_inode(fs, *((uuid_t *)new_meta));
-if (!@ARGNAME @.parent) {
- goto *err_label;
-}
-err_label = &&cleanup_ @ARGNAME @;
-gf_uuid_copy(@ARGNAME @.pargfid, @ARGNAME @.parent->gfid);
-new_meta += 16;
-if (!*(new_meta++)) {
- goto *err_label;
-}
-@ARGNAME @.name = new_meta;
-new_meta += strlen(new_meta) + 1;
+ loc_t @ARGNAME@ = { NULL, };
-@ARGNAME @.inode = inode_new(fs->active_subvol->itable);
-if (!@ARGNAME @.inode) {
- goto *err_label;
-}
+ new_meta += 16; /* skip over gfid */
+ @ARGNAME@.parent = recon_get_inode (fs, *((uuid_t *)new_meta));
+ if (!@ARGNAME@.parent) {
+ goto *err_label;
+ }
+ err_label = &&cleanup_@ARGNAME@;
+ gf_uuid_copy (@ARGNAME@.pargfid, @ARGNAME@.parent->gfid);
+ new_meta += 16;
+ if (!*(new_meta++)) {
+ goto *err_label;
+ }
+ @ARGNAME@.name = new_meta;
+ new_meta += strlen(new_meta) + 1;
+
+ @ARGNAME@.inode = inode_new (fs->active_subvol->itable);
+ if (!@ARGNAME@.inode) {
+ goto *err_label;
+ }
#pragma fragment PARENT_LOC_CLEANUP
-cleanup_ @ARGNAME @ : loc_wipe(&@ARGNAME @);
+cleanup_@ARGNAME@:
+ loc_wipe (&@ARGNAME@);
#pragma fragment STRING
-char *@ARGNAME @;
-if (*(new_meta++)) {
- @ARGNAME @ = new_meta;
- new_meta += (strlen(new_meta) + 1);
-} else {
- goto *err_label;
-}
+ char *@ARGNAME@;
+ if (*(new_meta++)) {
+ @ARGNAME@ = new_meta;
+ new_meta += (strlen(new_meta) + 1);
+ }
+ else {
+ goto *err_label;
+ }
#pragma fragment VECTOR
-struct iovec @ARGNAME @;
+ struct iovec @ARGNAME@;
-@ARGNAME @.iov_len = *((size_t *)new_meta);
-new_meta += sizeof(@ARGNAME @.iov_len);
-@ARGNAME @.iov_base = new_data;
-new_data += @ARGNAME @.iov_len;
+ @ARGNAME@.iov_len = *((size_t *)new_meta);
+ new_meta += sizeof(@ARGNAME@.iov_len);
+ @ARGNAME@.iov_base = new_data;
+ new_data += @ARGNAME@.iov_len;
#pragma fragment IATT
-struct iatt @ARGNAME @;
-{
- @ARGNAME @.ia_prot = *((ia_prot_t *)new_meta);
- new_meta += sizeof(ia_prot_t);
- uint32_t *myints = (uint32_t *)new_meta;
- @ARGNAME @.ia_uid = myints[0];
- @ARGNAME @.ia_gid = myints[1];
- @ARGNAME @.ia_atime = myints[2];
- @ARGNAME @.ia_atime_nsec = myints[3];
- @ARGNAME @.ia_mtime = myints[4];
- @ARGNAME @.ia_mtime_nsec = myints[5];
- new_meta += sizeof(*myints) * 6;
-}
+ struct iatt @ARGNAME@;
+ {
+ @ARGNAME@.ia_prot = *((ia_prot_t *)new_meta);
+ new_meta += sizeof(ia_prot_t);
+ uint32_t *myints = (uint32_t *)new_meta;
+ @ARGNAME@.ia_uid = myints[0];
+ @ARGNAME@.ia_gid = myints[1];
+ @ARGNAME@.ia_atime = myints[2];
+ @ARGNAME@.ia_atime_nsec = myints[3];
+ @ARGNAME@.ia_mtime = myints[4];
+ @ARGNAME@.ia_mtime_nsec = myints[5];
+ new_meta += sizeof(*myints) * 6;
+ }
#pragma fragment IOBREF
-struct iobref *@ARGNAME @;
+ struct iobref *@ARGNAME@;
-@ARGNAME @ = iobref_new();
-if (!@ARGNAME @) {
- goto *err_label;
-}
-err_label = &&cleanup_ @ARGNAME @;
+ @ARGNAME@ = iobref_new();
+ if (!@ARGNAME@) {
+ goto *err_label;
+ }
+ err_label = &&cleanup_@ARGNAME@;
#pragma fragment IOBREF_CLEANUP
-cleanup_ @ARGNAME @ : iobref_unref(@ARGNAME @);
+cleanup_@ARGNAME@:
+ iobref_unref (@ARGNAME@);
#pragma fragment LINK
-/* TBD: check error */
-inode_t *new_inode = inode_link(@INODE_ARG @, NULL, NULL, @IATT_ARG @);
-if (new_inode) {
- inode_lookup(new_inode);
-}
+ /* TBD: check error */
+ inode_t *new_inode = inode_link (@INODE_ARG@, NULL, NULL, @IATT_ARG@);
+ if (new_inode) {
+ inode_lookup (new_inode);
+ }
#pragma fragment FOP
-int fdl_replay_ @NAME @(glfs_t *fs, char **old_meta, char **old_data)
+int
+fdl_replay_@NAME@ (glfs_t *fs, char **old_meta, char **old_data)
{
- char *new_meta = *old_meta;
- char *new_data = *old_data;
- int ret;
- int status = 0xbad;
- void *err_label = &&done;
-
- @FUNCTION_BODY @
-
- ret = syncop_ @NAME @(fs->active_subvol, @SYNCOP_ARGS @, NULL);
- if (ret != @SUCCESS_VALUE @) {
- fprintf(stderr, "syncop_@NAME@ returned %d", ret);
- goto *err_label;
- }
+ char *new_meta = *old_meta;
+ char *new_data = *old_data;
+ int ret;
+ int status = 0xbad;
+ void *err_label = &&done;
+
+@FUNCTION_BODY@
+
+ ret = syncop_@NAME@ (fs->active_subvol, @SYNCOP_ARGS@, NULL);
+ if (ret != @SUCCESS_VALUE@) {
+ fprintf (stderr, "syncop_@NAME@ returned %d", ret);
+ goto *err_label;
+ }
- @LINKS @
+@LINKS@
status = 0;
- @CLEANUPS @
+@CLEANUPS@
- done : *old_meta = new_meta;
- *old_data = new_data;
- return status;
+done:
+ *old_meta = new_meta;
+ *old_data = new_data;
+ return status;
}
#pragma fragment CASE
-case GF_FOP_ @UPNAME @:
- printf("=== GF_FOP_@UPNAME@\n");
- if (fdl_replay_ @NAME @(fs, &new_meta, &new_data) != 0) {
- goto done;
- }
- recognized = 1;
- break;
+ case GF_FOP_@UPNAME@:
+ printf ("=== GF_FOP_@UPNAME@\n");
+ if (fdl_replay_@NAME@ (fs, &new_meta, &new_data) != 0) {
+ goto done;
+ }
+ recognized = 1;
+ break;
#pragma fragment EPILOG
- int
- recon_execute(glfs_t *fs, char **old_meta, char **old_data)
- {
- char *new_meta = *old_meta;
- char *new_data = *old_data;
- int recognized = 0;
- event_header_t *eh;
+int
+recon_execute (glfs_t *fs, char **old_meta, char **old_data)
+{
+ char *new_meta = *old_meta;
+ char *new_data = *old_data;
+ int recognized = 0;
+ event_header_t *eh;
eh = (event_header_t *)new_meta;
- new_meta += sizeof(*eh);
+ new_meta += sizeof (*eh);
/* TBD: check event_type instead of assuming NEW_REQUEST */
switch (eh->fop_type) {
- @SWITCH_BODY @
+@SWITCH_BODY@
- default : printf("unknown fop %u\n", eh->fop_type);
+ default:
+ printf ("unknown fop %u\n", eh->fop_type);
}
- done:
+done:
*old_meta = new_meta;
*old_data = new_data;
return recognized;
- }
+}