Land part 2 of clang-format changes

Change-Id: Ia84cc24c8924e6d22d02ac15f611c10e26db99b4
Signed-off-by: Nigel Babu <nigelb@redhat.com>

1 files changed, 557 insertions, 653 deletions

diff --git a/xlators/encryption/crypt/src/atom.c b/xlators/encryption/crypt/src/atom.c
index fc90892fae8..8e9c4940abd 100644
--- a/xlators/encryption/crypt/src/atom.c
+++ b/xlators/encryption/crypt/src/atom.c
@@ -71,182 +71,182 @@
 /*
  * atom->offset_at()
  */
-static off_t offset_at_head(struct avec_config *conf)
+static off_t
+offset_at_head(struct avec_config *conf)
 {
-	return conf->aligned_offset;
+    return conf->aligned_offset;
 }
 
-static off_t offset_at_hole_head(call_frame_t *frame,
-					 struct object_cipher_info *object)
+static off_t
+offset_at_hole_head(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return offset_at_head(get_hole_conf(frame));
+    return offset_at_head(get_hole_conf(frame));
 }
 
-static off_t offset_at_data_head(call_frame_t *frame,
-					 struct object_cipher_info *object)
+static off_t
+offset_at_data_head(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return offset_at_head(get_data_conf(frame));
+    return offset_at_head(get_data_conf(frame));
 }
 
-
-static off_t offset_at_tail(struct avec_config *conf,
-				    struct object_cipher_info *object)
+static off_t
+offset_at_tail(struct avec_config *conf, struct object_cipher_info *object)
 {
-	return conf->aligned_offset +
-		(conf->off_in_head ? get_atom_size(object) : 0) +
-		(conf->nr_full_blocks << get_atom_bits(object));
+    return conf->aligned_offset +
+           (conf->off_in_head ? get_atom_size(object) : 0) +
+           (conf->nr_full_blocks << get_atom_bits(object));
 }
 
-static off_t offset_at_hole_tail(call_frame_t *frame,
-					 struct object_cipher_info *object)
+static off_t
+offset_at_hole_tail(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return offset_at_tail(get_hole_conf(frame), object);
+    return offset_at_tail(get_hole_conf(frame), object);
 }
 
-
-static off_t offset_at_data_tail(call_frame_t *frame,
-					 struct object_cipher_info *object)
+static off_t
+offset_at_data_tail(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return offset_at_tail(get_data_conf(frame), object);
+    return offset_at_tail(get_data_conf(frame), object);
 }
 
-static off_t offset_at_full(struct avec_config *conf,
-				    struct object_cipher_info *object)
+static off_t
+offset_at_full(struct avec_config *conf, struct object_cipher_info *object)
 {
-	return conf->aligned_offset +
-		(conf->off_in_head ? get_atom_size(object) : 0);
+    return conf->aligned_offset +
+           (conf->off_in_head ? get_atom_size(object) : 0);
 }
 
-static off_t offset_at_data_full(call_frame_t *frame,
-					 struct object_cipher_info *object)
+static off_t
+offset_at_data_full(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return offset_at_full(get_data_conf(frame), object);
+    return offset_at_full(get_data_conf(frame), object);
 }
 
-static off_t offset_at_hole_full(call_frame_t *frame,
-					 struct object_cipher_info *object)
+static off_t
+offset_at_hole_full(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return offset_at_full(get_hole_conf(frame), object);
+    return offset_at_full(get_hole_conf(frame), object);
 }
 
 /*
  * atom->io_size_nopad()
  */
 
-static uint32_t io_size_nopad_head(struct avec_config *conf,
-				   struct object_cipher_info *object)
+static uint32_t
+io_size_nopad_head(struct avec_config *conf, struct object_cipher_info *object)
 {
-	uint32_t gap_at_beg;
-	uint32_t gap_at_end;
+    uint32_t gap_at_beg;
+    uint32_t gap_at_end;
 
-	check_head_block(conf);
+    check_head_block(conf);
 
-	gap_at_beg = conf->off_in_head;
+    gap_at_beg = conf->off_in_head;
 
-	if (has_tail_block(conf) || has_full_blocks(conf) || conf->off_in_tail == 0 )
-		gap_at_end = 0;
-	else
-		gap_at_end = get_atom_size(object) - conf->off_in_tail;
+    if (has_tail_block(conf) || has_full_blocks(conf) || conf->off_in_tail == 0)
+        gap_at_end = 0;
+    else
+        gap_at_end = get_atom_size(object) - conf->off_in_tail;
 
-	return get_atom_size(object) - (gap_at_beg + gap_at_end);
+    return get_atom_size(object) - (gap_at_beg + gap_at_end);
 }
 
-static uint32_t io_size_nopad_tail(struct avec_config *conf,
-				   struct object_cipher_info *object)
+static uint32_t
+io_size_nopad_tail(struct avec_config *conf, struct object_cipher_info *object)
 {
-	check_tail_block(conf);
-	return conf->off_in_tail;
+    check_tail_block(conf);
+    return conf->off_in_tail;
 }
 
-static uint32_t io_size_nopad_full(struct avec_config *conf,
-				   struct object_cipher_info *object)
+static uint32_t
+io_size_nopad_full(struct avec_config *conf, struct object_cipher_info *object)
 {
-	check_full_block(conf);
-	return get_atom_size(object);
+    check_full_block(conf);
+    return get_atom_size(object);
 }
 
-static uint32_t io_size_nopad_data_head(call_frame_t *frame,
-					struct object_cipher_info *object)
+static uint32_t
+io_size_nopad_data_head(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return io_size_nopad_head(get_data_conf(frame), object);
+    return io_size_nopad_head(get_data_conf(frame), object);
 }
 
-static uint32_t io_size_nopad_hole_head(call_frame_t *frame,
-					struct object_cipher_info *object)
+static uint32_t
+io_size_nopad_hole_head(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return io_size_nopad_head(get_hole_conf(frame), object);
+    return io_size_nopad_head(get_hole_conf(frame), object);
 }
 
-static uint32_t io_size_nopad_data_tail(call_frame_t *frame,
-					struct object_cipher_info *object)
+static uint32_t
+io_size_nopad_data_tail(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return io_size_nopad_tail(get_data_conf(frame), object);
+    return io_size_nopad_tail(get_data_conf(frame), object);
 }
 
-static uint32_t io_size_nopad_hole_tail(call_frame_t *frame,
-					struct object_cipher_info *object)
+static uint32_t
+io_size_nopad_hole_tail(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return io_size_nopad_tail(get_hole_conf(frame), object);
+    return io_size_nopad_tail(get_hole_conf(frame), object);
 }
 
-static uint32_t io_size_nopad_data_full(call_frame_t *frame,
-					struct object_cipher_info *object)
+static uint32_t
+io_size_nopad_data_full(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return io_size_nopad_full(get_data_conf(frame), object);
+    return io_size_nopad_full(get_data_conf(frame), object);
 }
 
-static uint32_t io_size_nopad_hole_full(call_frame_t *frame,
-					struct object_cipher_info *object)
+static uint32_t
+io_size_nopad_hole_full(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return io_size_nopad_full(get_hole_conf(frame), object);
+    return io_size_nopad_full(get_hole_conf(frame), object);
 }
 
-static uint32_t offset_in_head(struct avec_config *conf)
+static uint32_t
+offset_in_head(struct avec_config *conf)
 {
-	check_cursor_head(conf);
+    check_cursor_head(conf);
 
-	return conf->off_in_head;
+    return conf->off_in_head;
 }
 
-static uint32_t offset_in_tail(call_frame_t *frame,
-			       struct object_cipher_info *object)
+static uint32_t
+offset_in_tail(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return 0;
+    return 0;
 }
 
-static uint32_t offset_in_full(struct avec_config *conf,
-			       struct object_cipher_info *object)
+static uint32_t
+offset_in_full(struct avec_config *conf, struct object_cipher_info *object)
 {
-	check_cursor_full(conf);
+    check_cursor_full(conf);
 
-	if (has_head_block(conf))
-		return (conf->cursor - 1) << get_atom_bits(object);
-	else
-		return conf->cursor << get_atom_bits(object);
+    if (has_head_block(conf))
+        return (conf->cursor - 1) << get_atom_bits(object);
+    else
+        return conf->cursor << get_atom_bits(object);
 }
 
-static uint32_t offset_in_data_head(call_frame_t *frame,
-				    struct object_cipher_info *object)
+static uint32_t
+offset_in_data_head(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return offset_in_head(get_data_conf(frame));
+    return offset_in_head(get_data_conf(frame));
 }
 
-static uint32_t offset_in_hole_head(call_frame_t *frame,
-				    struct object_cipher_info *object)
+static uint32_t
+offset_in_hole_head(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return offset_in_head(get_hole_conf(frame));
+    return offset_in_head(get_hole_conf(frame));
 }
 
-static uint32_t offset_in_data_full(call_frame_t *frame,
-				    struct object_cipher_info *object)
+static uint32_t
+offset_in_data_full(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return offset_in_full(get_data_conf(frame), object);
+    return offset_in_full(get_data_conf(frame), object);
 }
 
-static uint32_t offset_in_hole_full(call_frame_t *frame,
-				    struct object_cipher_info *object)
+static uint32_t
+offset_in_hole_full(call_frame_t *frame, struct object_cipher_info *object)
 {
-	return offset_in_full(get_hole_conf(frame), object);
+    return offset_in_full(get_hole_conf(frame), object);
 }
 
 /*
@@ -261,94 +261,88 @@ static uint32_t offset_in_hole_full(call_frame_t *frame,
  * this plain text, encrypt the whole block
  * and write the result to disk.
  */
-static int32_t rmw_partial_block(call_frame_t *frame,
-				 void *cookie,
-				 xlator_t *this,
-				 int32_t op_ret,
-				 int32_t op_errno,
-				 struct iovec *vec,
-				 int32_t count,
-				 struct iatt *stbuf,
-				 struct iobref *iobref,
-				 struct rmw_atom *atom)
-{
-	size_t was_read = 0;
-	uint64_t file_size;
-	crypt_local_t *local = frame->local;
-	struct object_cipher_info *object = &local->info->cinfo;
-
-	struct iovec *partial = atom->get_iovec(frame, 0);
-	struct avec_config *conf = atom->get_config(frame);
-	end_writeback_handler_t end_writeback_partial_block;
+static int32_t
+rmw_partial_block(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iovec *vec,
+                  int32_t count, struct iatt *stbuf, struct iobref *iobref,
+                  struct rmw_atom *atom)
+{
+    size_t was_read = 0;
+    uint64_t file_size;
+    crypt_local_t *local = frame->local;
+    struct object_cipher_info *object = &local->info->cinfo;
+
+    struct iovec *partial = atom->get_iovec(frame, 0);
+    struct avec_config *conf = atom->get_config(frame);
+    end_writeback_handler_t end_writeback_partial_block;
 #if DEBUG_CRYPT
-	gf_boolean_t check_last_cblock = _gf_false;
+    gf_boolean_t check_last_cblock = _gf_false;
 #endif
-	local->op_ret = op_ret;
-	local->op_errno = op_errno;
-
-	if (op_ret < 0)
-		goto exit;
-
-	file_size = local->cur_file_size;
-	was_read = op_ret;
-
-	if (atom->locality == HEAD_ATOM && conf->off_in_head) {
-		/*
-		 * head atom with a non-uptodate gap
-		 * at the beginning
-		 *
-		 * fill the gap with plain text of the
-		 * latest version. Convert a part of hole
-		 * (if any) to zeros.
-		 */
-		int32_t i;
-		int32_t copied = 0;
-		int32_t to_gap; /* amount of data needed to uptodate
-				   the gap at the beginning */
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+
+    if (op_ret < 0)
+        goto exit;
+
+    file_size = local->cur_file_size;
+    was_read = op_ret;
+
+    if (atom->locality == HEAD_ATOM && conf->off_in_head) {
+        /*
+         * head atom with a non-uptodate gap
+         * at the beginning
+         *
+         * fill the gap with plain text of the
+         * latest version. Convert a part of hole
+         * (if any) to zeros.
+         */
+        int32_t i;
+        int32_t copied = 0;
+        int32_t to_gap; /* amount of data needed to uptodate
+                           the gap at the beginning */
 #if 0
 		int32_t hole = 0; /* The part of the hole which
 				   * got in the head block */
 #endif /* 0 */
-		to_gap = conf->off_in_head;
-
-		if (was_read < to_gap) {
-			if (file_size >
-			    offset_at_head(conf) + was_read) {
-				/*
-				 * It is impossible to uptodate
-				 * head block: too few bytes have
-				 * been read from disk, so that
-				 * partial write is impossible.
-				 *
-				 * It could happen because of many
-				 * reasons: IO errors, (meta)data
-				 * corruption in the local file system,
-				 * etc.
-				 */
-				gf_log(this->name, GF_LOG_WARNING,
-				     "Can not uptodate a gap at the beginning");
-				local->op_ret = -1;
-				local->op_errno = EIO;
-				goto exit;
-			}
+        to_gap = conf->off_in_head;
+
+        if (was_read < to_gap) {
+            if (file_size > offset_at_head(conf) + was_read) {
+                /*
+                 * It is impossible to uptodate
+                 * head block: too few bytes have
+                 * been read from disk, so that
+                 * partial write is impossible.
+                 *
+                 * It could happen because of many
+                 * reasons: IO errors, (meta)data
+                 * corruption in the local file system,
+                 * etc.
+                 */
+                gf_log(this->name, GF_LOG_WARNING,
+                       "Can not uptodate a gap at the beginning");
+                local->op_ret = -1;
+                local->op_errno = EIO;
+                goto exit;
+            }
 #if 0
 			hole = to_gap - was_read;
 #endif /* 0 */
-			to_gap = was_read;
-		}
-		/*
-		 * uptodate the gap at the beginning
-		 */
-		for (i = 0; i < count && copied < to_gap; i++) {
-			int32_t to_copy;
-
-			to_copy = vec[i].iov_len;
-			if (to_copy > to_gap - copied)
-				to_copy = to_gap - copied;
-
-			memcpy(partial->iov_base, vec[i].iov_base, to_copy);
-			copied += to_copy;
-		}
+            to_gap = was_read;
+        }
+        /*
+         * uptodate the gap at the beginning
+         */
+        for (i = 0; i < count && copied < to_gap; i++) {
+            int32_t to_copy;
+
+            to_copy = vec[i].iov_len;
+            if (to_copy > to_gap - copied)
+                to_copy = to_gap - copied;
+
+            memcpy(partial->iov_base, vec[i].iov_base, to_copy);
+            copied += to_copy;
+        }
 #if 0
 		/*
 		 * If possible, convert part of the
@@ -386,146 +380,128 @@ static int32_t rmw_partial_block(call_frame_t *frame,
 		      */
 			;
 #endif /* 0 */
-	}
-	if (atom->locality == TAIL_ATOM ||
-	    (!has_tail_block(conf) && conf->off_in_tail)) {
-		/*
-		 * tail atom, or head atom with a non-uptodate
-		 * gap at the end.
-		 *
-		 * fill the gap at the end of the block
-		 * with plain text of the latest version.
-		 * Pad the result, (if needed)
-		 */
-		int32_t i;
-		int32_t to_gap;
-		int copied;
-		off_t off_in_tail;
-		int32_t to_copy;
-
-		off_in_tail = conf->off_in_tail;
-		to_gap = conf->gap_in_tail;
-
-		if (to_gap && was_read < off_in_tail + to_gap) {
-			/*
-			 * It is impossible to uptodate
-			 * the gap at the end: too few bytes
-			 * have been read from disk, so that
-			 * partial write is impossible.
-			 *
-			 * It could happen because of many
-			 * reasons: IO errors, (meta)data
-			 * corruption in the local file system,
-			 * etc.
-			 */
-			gf_log(this->name, GF_LOG_WARNING,
-			       "Can not uptodate a gap at the end");
-			local->op_ret = -1;
-			local->op_errno = EIO;
-			goto exit;
-		}
-		/*
-		 * uptodate the gap at the end
-		 */
-		copied = 0;
-		to_copy = to_gap;
-		for(i = count - 1; i >= 0 && to_copy > 0; i--) {
-			uint32_t from_vec, off_in_vec;
-
-			off_in_vec = 0;
-			from_vec = vec[i].iov_len;
-			if (from_vec > to_copy) {
-				off_in_vec = from_vec - to_copy;
-				from_vec = to_copy;
-			}
-			memcpy(partial->iov_base +
-			       off_in_tail + to_gap - copied - from_vec,
-			       vec[i].iov_base + off_in_vec,
-			       from_vec);
-
-			gf_log(this->name, GF_LOG_DEBUG,
-			       "uptodate %d bytes at tail. Offset at target(source): %d(%d)",
-			       (int)from_vec,
-			       (int)off_in_tail + to_gap - copied - from_vec,
-			       (int)off_in_vec);
-
-			copied += from_vec;
-			to_copy -= from_vec;
-		}
-		partial->iov_len = off_in_tail + to_gap;
-
-		if (object_alg_should_pad(object)) {
-			int32_t resid = 0;
-			resid = partial->iov_len & (object_alg_blksize(object) - 1);
-			if (resid) {
-				/*
-				 * append a new EOF padding
-				 */
-				local->eof_padding_size =
-					object_alg_blksize(object) - resid;
-
-				gf_log(this->name, GF_LOG_DEBUG,
-				       "set padding size %d",
-				       local->eof_padding_size);
-
-				memset(partial->iov_base + partial->iov_len,
-				       1,
-				       local->eof_padding_size);
-				partial->iov_len += local->eof_padding_size;
+    }
+    if (atom->locality == TAIL_ATOM ||
+        (!has_tail_block(conf) && conf->off_in_tail)) {
+        /*
+         * tail atom, or head atom with a non-uptodate
+         * gap at the end.
+         *
+         * fill the gap at the end of the block
+         * with plain text of the latest version.
+         * Pad the result, (if needed)
+         */
+        int32_t i;
+        int32_t to_gap;
+        int copied;
+        off_t off_in_tail;
+        int32_t to_copy;
+
+        off_in_tail = conf->off_in_tail;
+        to_gap = conf->gap_in_tail;
+
+        if (to_gap && was_read < off_in_tail + to_gap) {
+            /*
+             * It is impossible to uptodate
+             * the gap at the end: too few bytes
+             * have been read from disk, so that
+             * partial write is impossible.
+             *
+             * It could happen because of many
+             * reasons: IO errors, (meta)data
+             * corruption in the local file system,
+             * etc.
+             */
+            gf_log(this->name, GF_LOG_WARNING,
+                   "Can not uptodate a gap at the end");
+            local->op_ret = -1;
+            local->op_errno = EIO;
+            goto exit;
+        }
+        /*
+         * uptodate the gap at the end
+         */
+        copied = 0;
+        to_copy = to_gap;
+        for (i = count - 1; i >= 0 && to_copy > 0; i--) {
+            uint32_t from_vec, off_in_vec;
+
+            off_in_vec = 0;
+            from_vec = vec[i].iov_len;
+            if (from_vec > to_copy) {
+                off_in_vec = from_vec - to_copy;
+                from_vec = to_copy;
+            }
+            memcpy(partial->iov_base + off_in_tail + to_gap - copied - from_vec,
+                   vec[i].iov_base + off_in_vec, from_vec);
+
+            gf_log(
+                this->name, GF_LOG_DEBUG,
+                "uptodate %d bytes at tail. Offset at target(source): %d(%d)",
+                (int)from_vec, (int)off_in_tail + to_gap - copied - from_vec,
+                (int)off_in_vec);
+
+            copied += from_vec;
+            to_copy -= from_vec;
+        }
+        partial->iov_len = off_in_tail + to_gap;
+
+        if (object_alg_should_pad(object)) {
+            int32_t resid = 0;
+            resid = partial->iov_len & (object_alg_blksize(object) - 1);
+            if (resid) {
+                /*
+                 * append a new EOF padding
+                 */
+                local->eof_padding_size = object_alg_blksize(object) - resid;
+
+                gf_log(this->name, GF_LOG_DEBUG, "set padding size %d",
+                       local->eof_padding_size);
+
+                memset(partial->iov_base + partial->iov_len, 1,
+                       local->eof_padding_size);
+                partial->iov_len += local->eof_padding_size;
 #if DEBUG_CRYPT
-				gf_log(this->name, GF_LOG_DEBUG,
-				       "pad cblock with %d zeros:",
-				       local->eof_padding_size);
-				dump_cblock(this,
-					    (unsigned char *)partial->iov_base +
-					    partial->iov_len - object_alg_blksize(object));
-				check_last_cblock = _gf_true;
+                gf_log(this->name, GF_LOG_DEBUG,
+                       "pad cblock with %d zeros:", local->eof_padding_size);
+                dump_cblock(this, (unsigned char *)partial->iov_base +
+                                      partial->iov_len -
+                                      object_alg_blksize(object));
+                check_last_cblock = _gf_true;
 #endif
-			}
-		}
-	}
-	/*
-	 * encrypt the whole block
-	 */
-	encrypt_aligned_iov(object,
-			    partial,
-			    1,
-			    atom->offset_at(frame, object));
+            }
+        }
+    }
+    /*
+     * encrypt the whole block
+     */
+    encrypt_aligned_iov(object, partial, 1, atom->offset_at(frame, object));
 #if DEBUG_CRYPT
-	if (check_last_cblock == _gf_true) {
-		gf_log(this->name, GF_LOG_DEBUG,
-		       "encrypt last cblock with offset %llu",
-		       (unsigned long long)atom->offset_at(frame, object));
-		dump_cblock(this, (unsigned char *)partial->iov_base +
-			    partial->iov_len - object_alg_blksize(object));
-	}
+    if (check_last_cblock == _gf_true) {
+        gf_log(this->name, GF_LOG_DEBUG, "encrypt last cblock with offset %llu",
+               (unsigned long long)atom->offset_at(frame, object));
+        dump_cblock(this, (unsigned char *)partial->iov_base +
+                              partial->iov_len - object_alg_blksize(object));
+    }
 #endif
-	set_local_io_params_writev(frame, object, atom,
-				   atom->offset_at(frame, object),
-				   iov_length(partial, 1));
-	/*
-	 * write the whole block to disk
-	 */
-	end_writeback_partial_block = dispatch_end_writeback(local->fop);
-	conf->cursor ++;
-	STACK_WIND(frame,
-		   end_writeback_partial_block,
-		   FIRST_CHILD(this),
-		   FIRST_CHILD(this)->fops->writev,
-		   local->fd,
-		   partial,
-		   1,
-		   atom->offset_at(frame, object),
-		   local->flags,
-		   local->iobref_data,
-		   local->xdata);
-
-	gf_log("crypt", GF_LOG_DEBUG,
-	       "submit partial block: %d bytes from %d offset",
-	       (int)iov_length(partial, 1),
-	       (int)atom->offset_at(frame, object));
- exit:
-	return 0;
+    set_local_io_params_writev(frame, object, atom,
+                               atom->offset_at(frame, object),
+                               iov_length(partial, 1));
+    /*
+     * write the whole block to disk
+     */
+    end_writeback_partial_block = dispatch_end_writeback(local->fop);
+    conf->cursor++;
+    STACK_WIND(frame, end_writeback_partial_block, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->writev, local->fd, partial, 1,
+               atom->offset_at(frame, object), local->flags, local->iobref_data,
+               local->xdata);
+
+    gf_log("crypt", GF_LOG_DEBUG,
+           "submit partial block: %d bytes from %d offset",
+           (int)iov_length(partial, 1), (int)atom->offset_at(frame, object));
+exit:
+    return 0;
 }
 
 /*
@@ -534,415 +510,343 @@ static int32_t rmw_partial_block(call_frame_t *frame,
  * of upper server-side manager, i.e. the caller
  * needs to make sure this is his turn to rmw.
  */
-void submit_partial(call_frame_t *frame,
-		    xlator_t *this,
-		    fd_t *fd,
-		    atom_locality_type ltype)
-{
-	int32_t ret;
-	dict_t *dict;
-	struct rmw_atom *atom;
-	crypt_local_t *local = frame->local;
-	struct object_cipher_info *object = &local->info->cinfo;
-
-	atom = atom_by_types(local->active_setup, ltype);
-	/*
-	 * To perform the "read" component of the read-modify-write
-	 * sequence the crypt translator does stack_wind to itself.
-	 *
-	 * Pass current file size to crypt_readv()
-	 */
-	dict = dict_new();
-	if (!dict) {
-		/*
-		 * FIXME: Handle the error
-		 */
-		gf_log("crypt", GF_LOG_WARNING, "Can not alloc dict");
-		return;
-	}
-	ret = dict_set(dict,
-		       FSIZE_XATTR_PREFIX,
-		       data_from_uint64(local->cur_file_size));
-	if (ret) {
-		/*
-		 * FIXME: Handle the error
-		 */
-		dict_unref(dict);
-		gf_log("crypt", GF_LOG_WARNING, "Can not set dict");
-		goto exit;
-	}
-	STACK_WIND(frame,
-		   atom->rmw,
-		   this,
-		   this->fops->readv, /* crypt_readv */
-		   fd,
-		   atom->count_to_uptodate(frame, object), /* count */
-		   atom->offset_at(frame, object), /* offset to read from */
-		   0,
-		   dict);
- exit:
-	dict_unref(dict);
+void
+submit_partial(call_frame_t *frame, xlator_t *this, fd_t *fd,
+               atom_locality_type ltype)
+{
+    int32_t ret;
+    dict_t *dict;
+    struct rmw_atom *atom;
+    crypt_local_t *local = frame->local;
+    struct object_cipher_info *object = &local->info->cinfo;
+
+    atom = atom_by_types(local->active_setup, ltype);
+    /*
+     * To perform the "read" component of the read-modify-write
+     * sequence the crypt translator does stack_wind to itself.
+     *
+     * Pass current file size to crypt_readv()
+     */
+    dict = dict_new();
+    if (!dict) {
+        /*
+         * FIXME: Handle the error
+         */
+        gf_log("crypt", GF_LOG_WARNING, "Can not alloc dict");
+        return;
+    }
+    ret = dict_set(dict, FSIZE_XATTR_PREFIX,
+                   data_from_uint64(local->cur_file_size));
+    if (ret) {
+        /*
+         * FIXME: Handle the error
+         */
+        dict_unref(dict);
+        gf_log("crypt", GF_LOG_WARNING, "Can not set dict");
+        goto exit;
+    }
+    STACK_WIND(frame, atom->rmw, this, this->fops->readv,  /* crypt_readv */
+               fd, atom->count_to_uptodate(frame, object), /* count */
+               atom->offset_at(frame, object), /* offset to read from */
+               0, dict);
+exit:
+    dict_unref(dict);
 }
 
 /*
  * submit blocks of FULL_ATOM type
  */
-void submit_full(call_frame_t *frame, xlator_t *this)
-{
-	crypt_local_t *local = frame->local;
-	struct object_cipher_info *object = &local->info->cinfo;
-	struct rmw_atom *atom = atom_by_types(local->active_setup, FULL_ATOM);
-	uint32_t count; /* total number of full blocks to submit */
-	uint32_t granularity; /* number of blocks to submit in one iteration */
-
-	uint64_t off_in_file; /* start offset in the file, bytes */
-	uint32_t off_in_atom; /* start offset in the atom, blocks */
-	uint32_t blocks_written = 0; /* blocks written for this submit */
-
-	struct avec_config *conf = atom->get_config(frame);
-	end_writeback_handler_t end_writeback_full_block;
-	/*
-	 * Write full blocks by groups of granularity size.
-	 */
-	end_writeback_full_block = dispatch_end_writeback(local->fop);
-
-	if (is_ordered_mode(frame)) {
-		uint32_t skip = has_head_block(conf) ? 1 : 0;
-		count = 1;
-		granularity = 1;
-		/*
-		 * calculate start offset using cursor value;
-		 * here we should take into account head block,
-		 * which corresponds to cursor value 0.
-		 */
-		off_in_file = atom->offset_at(frame, object) +
-			((conf->cursor - skip) << get_atom_bits(object));
-		off_in_atom = conf->cursor - skip;
-	}
-	else {
-		/*
-		 * in parallel mode
-		 */
-		count = conf->nr_full_blocks;
-		granularity = MAX_IOVEC;
-		off_in_file = atom->offset_at(frame, object);
-		off_in_atom = 0;
-	}
-	while (count) {
-		uint32_t blocks_to_write = count;
-
-		if (blocks_to_write > granularity)
-			blocks_to_write = granularity;
-		if (conf->type == HOLE_ATOM)
-			/*
-			 * reset iovec before encryption
-			 */
-			memset(atom->get_iovec(frame, 0)->iov_base,
-			       0,
-			       get_atom_size(object));
-		/*
-		 * encrypt the group
-		 */
-		encrypt_aligned_iov(object,
-				    atom->get_iovec(frame,
-						    off_in_atom +
-						    blocks_written),
-				    blocks_to_write,
-				    off_in_file + (blocks_written <<
-						   get_atom_bits(object)));
-
-		set_local_io_params_writev(frame, object, atom,
-		        off_in_file + (blocks_written << get_atom_bits(object)),
-			blocks_to_write <<  get_atom_bits(object));
-
-		conf->cursor += blocks_to_write;
-
-		STACK_WIND(frame,
-			   end_writeback_full_block,
-			   FIRST_CHILD(this),
-			   FIRST_CHILD(this)->fops->writev,
-			   local->fd,
-			   atom->get_iovec(frame, off_in_atom + blocks_written),
-			   blocks_to_write,
-			   off_in_file + (blocks_written << get_atom_bits(object)),
-			   local->flags,
-			   local->iobref_data ? local->iobref_data : local->iobref,
-			   local->xdata);
-
-		gf_log("crypt", GF_LOG_DEBUG, "submit %d full blocks from %d offset",
-		       blocks_to_write,
-		       (int)(off_in_file + (blocks_written << get_atom_bits(object))));
-
-		count -= blocks_to_write;
-		blocks_written += blocks_to_write;
-	}
-	return;
-}
-
-static int32_t rmw_data_head(call_frame_t *frame,
-			     void *cookie,
-			     xlator_t *this,
-			     int32_t op_ret,
-			     int32_t op_errno,
-			     struct iovec *vec,
-			     int32_t count,
-			     struct iatt *stbuf,
-			     struct iobref *iobref,
-			     dict_t *xdata)
-{
-	return rmw_partial_block(frame,
-				 cookie,
-				 this,
-				 op_ret,
-				 op_errno,
-				 vec,
-				 count,
-				 stbuf,
-				 iobref,
-				 atom_by_types(DATA_ATOM, HEAD_ATOM));
-}
-
-static int32_t rmw_data_tail(call_frame_t *frame,
-			     void *cookie,
-			     xlator_t *this,
-			     int32_t op_ret,
-			     int32_t op_errno,
-			     struct iovec *vec,
-			     int32_t count,
-			     struct iatt *stbuf,
-			     struct iobref *iobref,
-			     dict_t *xdata)
-{
-	return rmw_partial_block(frame,
-				 cookie,
-				 this,
-				 op_ret,
-				 op_errno,
-				 vec,
-				 count,
-				 stbuf,
-				 iobref,
-				 atom_by_types(DATA_ATOM, TAIL_ATOM));
-}
-
-static int32_t rmw_hole_head(call_frame_t *frame,
-			     void *cookie,
-			     xlator_t *this,
-			     int32_t op_ret,
-			     int32_t op_errno,
-			     struct iovec *vec,
-			     int32_t count,
-			     struct iatt *stbuf,
-			     struct iobref *iobref,
-			     dict_t *xdata)
-{
-	return rmw_partial_block(frame,
-				 cookie,
-				 this,
-				 op_ret,
-				 op_errno,
-				 vec,
-				 count,
-				 stbuf,
-				 iobref,
-				 atom_by_types(HOLE_ATOM, HEAD_ATOM));
-}
-
-static int32_t rmw_hole_tail(call_frame_t *frame,
-			     void *cookie,
-			     xlator_t *this,
-			     int32_t op_ret,
-			     int32_t op_errno,
-			     struct iovec *vec,
-			     int32_t count,
-			     struct iatt *stbuf,
-			     struct iobref *iobref,
-			     dict_t *xdata)
-{
-	return rmw_partial_block(frame,
-				 cookie,
-				 this,
-				 op_ret,
-				 op_errno,
-				 vec,
-				 count,
-				 stbuf,
-				 iobref,
-				 atom_by_types(HOLE_ATOM, TAIL_ATOM));
+void
+submit_full(call_frame_t *frame, xlator_t *this)
+{
+    crypt_local_t *local = frame->local;
+    struct object_cipher_info *object = &local->info->cinfo;
+    struct rmw_atom *atom = atom_by_types(local->active_setup, FULL_ATOM);
+    uint32_t count;       /* total number of full blocks to submit */
+    uint32_t granularity; /* number of blocks to submit in one iteration */
+
+    uint64_t off_in_file;        /* start offset in the file, bytes */
+    uint32_t off_in_atom;        /* start offset in the atom, blocks */
+    uint32_t blocks_written = 0; /* blocks written for this submit */
+
+    struct avec_config *conf = atom->get_config(frame);
+    end_writeback_handler_t end_writeback_full_block;
+    /*
+     * Write full blocks by groups of granularity size.
+     */
+    end_writeback_full_block = dispatch_end_writeback(local->fop);
+
+    if (is_ordered_mode(frame)) {
+        uint32_t skip = has_head_block(conf) ? 1 : 0;
+        count = 1;
+        granularity = 1;
+        /*
+         * calculate start offset using cursor value;
+         * here we should take into account head block,
+         * which corresponds to cursor value 0.
+         */
+        off_in_file = atom->offset_at(frame, object) +
+                      ((conf->cursor - skip) << get_atom_bits(object));
+        off_in_atom = conf->cursor - skip;
+    } else {
+        /*
+         * in parallel mode
+         */
+        count = conf->nr_full_blocks;
+        granularity = MAX_IOVEC;
+        off_in_file = atom->offset_at(frame, object);
+        off_in_atom = 0;
+    }
+    while (count) {
+        uint32_t blocks_to_write = count;
+
+        if (blocks_to_write > granularity)
+            blocks_to_write = granularity;
+        if (conf->type == HOLE_ATOM)
+            /*
+             * reset iovec before encryption
+             */
+            memset(atom->get_iovec(frame, 0)->iov_base, 0,
+                   get_atom_size(object));
+        /*
+         * encrypt the group
+         */
+        encrypt_aligned_iov(
+            object, atom->get_iovec(frame, off_in_atom + blocks_written),
+            blocks_to_write,
+            off_in_file + (blocks_written << get_atom_bits(object)));
+
+        set_local_io_params_writev(
+            frame, object, atom,
+            off_in_file + (blocks_written << get_atom_bits(object)),
+            blocks_to_write << get_atom_bits(object));
+
+        conf->cursor += blocks_to_write;
+
+        STACK_WIND(frame, end_writeback_full_block, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->writev, local->fd,
+                   atom->get_iovec(frame, off_in_atom + blocks_written),
+                   blocks_to_write,
+                   off_in_file + (blocks_written << get_atom_bits(object)),
+                   local->flags,
+                   local->iobref_data ? local->iobref_data : local->iobref,
+                   local->xdata);
+
+        gf_log("crypt", GF_LOG_DEBUG, "submit %d full blocks from %d offset",
+               blocks_to_write,
+               (int)(off_in_file + (blocks_written << get_atom_bits(object))));
+
+        count -= blocks_to_write;
+        blocks_written += blocks_to_write;
+    }
+    return;
+}
+
+static int32_t
+rmw_data_head(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct iovec *vec, int32_t count,
+              struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
+{
+    return rmw_partial_block(frame, cookie, this, op_ret, op_errno, vec, count,
+                             stbuf, iobref,
+                             atom_by_types(DATA_ATOM, HEAD_ATOM));
+}
+
+static int32_t
+rmw_data_tail(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct iovec *vec, int32_t count,
+              struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
+{
+    return rmw_partial_block(frame, cookie, this, op_ret, op_errno, vec, count,
+                             stbuf, iobref,
+                             atom_by_types(DATA_ATOM, TAIL_ATOM));
+}
+
+static int32_t
+rmw_hole_head(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct iovec *vec, int32_t count,
+              struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
+{
+    return rmw_partial_block(frame, cookie, this, op_ret, op_errno, vec, count,
+                             stbuf, iobref,
+                             atom_by_types(HOLE_ATOM, HEAD_ATOM));
+}
+
+static int32_t
+rmw_hole_tail(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct iovec *vec, int32_t count,
+              struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
+{
+    return rmw_partial_block(frame, cookie, this, op_ret, op_errno, vec, count,
+                             stbuf, iobref,
+                             atom_by_types(HOLE_ATOM, TAIL_ATOM));
 }
 
 /*
  * atom->count_to_uptodate()
  */
-static uint32_t count_to_uptodate_head(struct avec_config *conf,
-				       struct object_cipher_info *object)
+static uint32_t
+count_to_uptodate_head(struct avec_config *conf,
+                       struct object_cipher_info *object)
 {
-	if (conf->acount == 1 && conf->off_in_tail)
-		return get_atom_size(object);
-	else
-		/* there is no need to read the whole head block */
-		return conf->off_in_head;
+    if (conf->acount == 1 && conf->off_in_tail)
+        return get_atom_size(object);
+    else
+        /* there is no need to read the whole head block */
+        return conf->off_in_head;
 }
 
-static uint32_t count_to_uptodate_tail(struct avec_config *conf,
-				       struct object_cipher_info *object)
+static uint32_t
+count_to_uptodate_tail(struct avec_config *conf,
+                       struct object_cipher_info *object)
 {
-	/* we need to read the whole tail block */
-	return get_atom_size(object);
+    /* we need to read the whole tail block */
+    return get_atom_size(object);
 }
 
-static uint32_t count_to_uptodate_data_head(call_frame_t *frame,
-					    struct object_cipher_info *object)
+static uint32_t
+count_to_uptodate_data_head(call_frame_t *frame,
+                            struct object_cipher_info *object)
 {
-	return count_to_uptodate_head(get_data_conf(frame), object);
+    return count_to_uptodate_head(get_data_conf(frame), object);
 }
 
-static uint32_t count_to_uptodate_data_tail(call_frame_t *frame,
-					    struct object_cipher_info *object)
+static uint32_t
+count_to_uptodate_data_tail(call_frame_t *frame,
+                            struct object_cipher_info *object)
 {
-	return count_to_uptodate_tail(get_data_conf(frame), object);
+    return count_to_uptodate_tail(get_data_conf(frame), object);
 }
 
-static uint32_t count_to_uptodate_hole_head(call_frame_t *frame,
-					    struct object_cipher_info *object)
+static uint32_t
+count_to_uptodate_hole_head(call_frame_t *frame,
+                            struct object_cipher_info *object)
 {
-	return count_to_uptodate_head(get_hole_conf(frame), object);
+    return count_to_uptodate_head(get_hole_conf(frame), object);
 }
 
-static uint32_t count_to_uptodate_hole_tail(call_frame_t *frame,
-					    struct object_cipher_info *object)
+static uint32_t
+count_to_uptodate_hole_tail(call_frame_t *frame,
+                            struct object_cipher_info *object)
 {
-	return count_to_uptodate_tail(get_hole_conf(frame), object);
+    return count_to_uptodate_tail(get_hole_conf(frame), object);
 }
 
 /* atom->get_config() */
 
-static struct avec_config *get_config_data(call_frame_t *frame)
+static struct avec_config *
+get_config_data(call_frame_t *frame)
 {
-	return &((crypt_local_t *)frame->local)->data_conf;
+    return &((crypt_local_t *)frame->local)->data_conf;
 }
 
-static struct avec_config *get_config_hole(call_frame_t *frame)
+static struct avec_config *
+get_config_hole(call_frame_t *frame)
 {
-	return &((crypt_local_t *)frame->local)->hole_conf;
+    return &((crypt_local_t *)frame->local)->hole_conf;
 }
 
 /*
  * atom->get_iovec()
  */
-static struct iovec *get_iovec_hole_head(call_frame_t *frame,
-					 uint32_t count)
+static struct iovec *
+get_iovec_hole_head(call_frame_t *frame, uint32_t count)
 {
-	struct avec_config *conf = get_hole_conf(frame);
+    struct avec_config *conf = get_hole_conf(frame);
 
-	return conf->avec;
+    return conf->avec;
 }
 
-static struct iovec *get_iovec_hole_full(call_frame_t *frame,
-					 uint32_t count)
+static struct iovec *
+get_iovec_hole_full(call_frame_t *frame, uint32_t count)
 {
-	struct avec_config *conf = get_hole_conf(frame);
+    struct avec_config *conf = get_hole_conf(frame);
 
-	return conf->avec + (conf->off_in_head ? 1 : 0);
+    return conf->avec + (conf->off_in_head ? 1 : 0);
 }
 
-static struct iovec *get_iovec_hole_tail(call_frame_t *frame,
-						uint32_t count)
+static struct iovec *
+get_iovec_hole_tail(call_frame_t *frame, uint32_t count)
 {
-	struct avec_config *conf = get_hole_conf(frame);
+    struct avec_config *conf = get_hole_conf(frame);
 
-	return conf->avec + (conf->blocks_in_pool - 1);
+    return conf->avec + (conf->blocks_in_pool - 1);
 }
 
-static struct iovec *get_iovec_data_head(call_frame_t *frame,
-						uint32_t count)
+static struct iovec *
+get_iovec_data_head(call_frame_t *frame, uint32_t count)
 {
-	struct avec_config *conf = get_data_conf(frame);
+    struct avec_config *conf = get_data_conf(frame);
 
-	return conf->avec;
+    return conf->avec;
 }
 
-static struct iovec *get_iovec_data_full(call_frame_t *frame,
-						uint32_t count)
+static struct iovec *
+get_iovec_data_full(call_frame_t *frame, uint32_t count)
 {
-	struct avec_config *conf = get_data_conf(frame);
+    struct avec_config *conf = get_data_conf(frame);
 
-	return conf->avec + (conf->off_in_head ? 1 : 0) + count;
+    return conf->avec + (conf->off_in_head ? 1 : 0) + count;
 }
 
-static struct iovec *get_iovec_data_tail(call_frame_t *frame,
-						uint32_t count)
+static struct iovec *
+get_iovec_data_tail(call_frame_t *frame, uint32_t count)
 {
-	struct avec_config *conf = get_data_conf(frame);
+    struct avec_config *conf = get_data_conf(frame);
 
-	return conf->avec +
-		(conf->off_in_head ? 1 : 0) +
-		conf->nr_full_blocks;
+    return conf->avec + (conf->off_in_head ? 1 : 0) + conf->nr_full_blocks;
 }
 
 static struct rmw_atom atoms[LAST_DATA_TYPE][LAST_LOCALITY_TYPE] = {
-	[DATA_ATOM][HEAD_ATOM] =
-	{ .locality = HEAD_ATOM,
-	  .rmw = rmw_data_head,
-	  .offset_at = offset_at_data_head,
-	  .offset_in = offset_in_data_head,
-	  .get_iovec = get_iovec_data_head,
-	  .io_size_nopad = io_size_nopad_data_head,
-	  .count_to_uptodate = count_to_uptodate_data_head,
-	  .get_config = get_config_data
-	},
-	[DATA_ATOM][TAIL_ATOM] =
-	{ .locality = TAIL_ATOM,
-	  .rmw = rmw_data_tail,
-	  .offset_at = offset_at_data_tail,
-	  .offset_in = offset_in_tail,
-	  .get_iovec = get_iovec_data_tail,
-	  .io_size_nopad = io_size_nopad_data_tail,
-	  .count_to_uptodate = count_to_uptodate_data_tail,
-	  .get_config = get_config_data
-	},
-	[DATA_ATOM][FULL_ATOM] =
-	{ .locality = FULL_ATOM,
-	  .offset_at = offset_at_data_full,
-	  .offset_in = offset_in_data_full,
-	  .get_iovec = get_iovec_data_full,
-	  .io_size_nopad = io_size_nopad_data_full,
-	  .get_config = get_config_data
-	},
-	[HOLE_ATOM][HEAD_ATOM] =
-	{ .locality = HEAD_ATOM,
-	  .rmw = rmw_hole_head,
-	  .offset_at = offset_at_hole_head,
-	  .offset_in = offset_in_hole_head,
-	  .get_iovec = get_iovec_hole_head,
-	  .io_size_nopad = io_size_nopad_hole_head,
-	  .count_to_uptodate = count_to_uptodate_hole_head,
-	  .get_config = get_config_hole
-	},
-	[HOLE_ATOM][TAIL_ATOM] =
-	{ .locality = TAIL_ATOM,
-	  .rmw = rmw_hole_tail,
-	  .offset_at = offset_at_hole_tail,
-	  .offset_in = offset_in_tail,
-	  .get_iovec = get_iovec_hole_tail,
-	  .io_size_nopad = io_size_nopad_hole_tail,
-	  .count_to_uptodate = count_to_uptodate_hole_tail,
-	  .get_config = get_config_hole
-	},
-	[HOLE_ATOM][FULL_ATOM] =
-	{ .locality = FULL_ATOM,
-	  .offset_at = offset_at_hole_full,
-	  .offset_in = offset_in_hole_full,
-	  .get_iovec = get_iovec_hole_full,
-	  .io_size_nopad = io_size_nopad_hole_full,
-	  .get_config = get_config_hole
-	}
-};
-
-struct rmw_atom *atom_by_types(atom_data_type data,
-			       atom_locality_type locality)
-{
-	return &atoms[data][locality];
+    [DATA_ATOM][HEAD_ATOM] = {.locality = HEAD_ATOM,
+                              .rmw = rmw_data_head,
+                              .offset_at = offset_at_data_head,
+                              .offset_in = offset_in_data_head,
+                              .get_iovec = get_iovec_data_head,
+                              .io_size_nopad = io_size_nopad_data_head,
+                              .count_to_uptodate = count_to_uptodate_data_head,
+                              .get_config = get_config_data},
+    [DATA_ATOM][TAIL_ATOM] = {.locality = TAIL_ATOM,
+                              .rmw = rmw_data_tail,
+                              .offset_at = offset_at_data_tail,
+                              .offset_in = offset_in_tail,
+                              .get_iovec = get_iovec_data_tail,
+                              .io_size_nopad = io_size_nopad_data_tail,
+                              .count_to_uptodate = count_to_uptodate_data_tail,
+                              .get_config = get_config_data},
+    [DATA_ATOM][FULL_ATOM] = {.locality = FULL_ATOM,
+                              .offset_at = offset_at_data_full,
+                              .offset_in = offset_in_data_full,
+                              .get_iovec = get_iovec_data_full,
+                              .io_size_nopad = io_size_nopad_data_full,
+                              .get_config = get_config_data},
+    [HOLE_ATOM][HEAD_ATOM] = {.locality = HEAD_ATOM,
+                              .rmw = rmw_hole_head,
+                              .offset_at = offset_at_hole_head,
+                              .offset_in = offset_in_hole_head,
+                              .get_iovec = get_iovec_hole_head,
+                              .io_size_nopad = io_size_nopad_hole_head,
+                              .count_to_uptodate = count_to_uptodate_hole_head,
+                              .get_config = get_config_hole},
+    [HOLE_ATOM][TAIL_ATOM] = {.locality = TAIL_ATOM,
+                              .rmw = rmw_hole_tail,
+                              .offset_at = offset_at_hole_tail,
+                              .offset_in = offset_in_tail,
+                              .get_iovec = get_iovec_hole_tail,
+                              .io_size_nopad = io_size_nopad_hole_tail,
+                              .count_to_uptodate = count_to_uptodate_hole_tail,
+                              .get_config = get_config_hole},
+    [HOLE_ATOM][FULL_ATOM] = {.locality = FULL_ATOM,
+                              .offset_at = offset_at_hole_full,
+                              .offset_in = offset_in_hole_full,
+                              .get_iovec = get_iovec_hole_full,
+                              .io_size_nopad = io_size_nopad_hole_full,
+                              .get_config = get_config_hole}};
+
+struct rmw_atom *
+atom_by_types(atom_data_type data, atom_locality_type locality)
+{
+    return &atoms[data][locality];
 }
 
 /*