/* Client MULTI/EXEC state */
typedef struct multiCmd {
 robj **argv;
 int argc;
 struct redisCommand *cmd;
} multiCmd;
typedef struct multiState {
 multiCmd *commands; /* Array of MULTI commands */
 int count; /* Total number of MULTI commands */
} multiState;
typedef struct redisClient {
 ---
 multiState mstate; /* MULTI/EXEC state */
 ---
} redisClient;

static void multiCommand(redisClient *c) {
 c->flags |= REDIS_MULTI;
 addReply(c,shared.ok);
}

static int processCommand(redisClient *c) {
 ---
 /* Exec the command */
 if (c->flags & REDIS_MULTI && cmd->proc != execCommand && cmd->proc != discardCommand) {
 queueMultiCommand(c,cmd);
 addReply(c,shared.queued);
 } else {
 if (server.vm_enabled && server.vm_max_threads > 0 &&
 blockClientOnSwappedKeys(c,cmd)) return 1;
 call(c,cmd);
 }
 ---
}

{"exec",execCommand,1,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM,execBlockClientOnSwappedKeys,0,0,0},

static void execCommand(redisClient *c) {
 int j;
 robj **orig_argv;
 int orig_argc;
 if (!(c->flags & REDIS_MULTI)) {
 addReplySds(c,sdsnew("-ERR EXEC without MULTI\r\n"));
 return;
 }
 /* Replicate a MULTI request now that we are sure the block is executed.
 * This way we'll deliver the MULTI/..../EXEC block as a whole and
 * both the AOF and the replication link will have the same consistency
 * and atomicity guarantees. */
 execCommandReplicateMulti(c);
 /* Exec all the queued commands */
 orig_argv = c->argv;
 orig_argc = c->argc;
 addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",c->mstate.count));
 for (j = 0; j < c->mstate.count; j++) {
 c->argc = c->mstate.commands[j].argc;
 c->argv = c->mstate.commands[j].argv;
 call(c,c->mstate.commands[j].cmd);
 }
 c->argv = orig_argv;
 c->argc = orig_argc;
 freeClientMultiState(c);
 initClientMultiState(c);
 c->flags &= (~REDIS_MULTI);
 /* Make sure the EXEC command is always replicated / AOF, since we
 * always send the MULTI command (we can't know beforehand if the
 * next operations will contain at least a modification to the DB). */
 server.dirty++;
}