static int unresolve_one(const char *path)
{
int namelen = strlen(path);
int pos;
int ret = 0;
struct cache_entry *ce_2 = NULL, *ce_3 = NULL;
/* See if there is such entry in the index. */
pos = cache_name_pos(path, namelen);
if (pos < 0) {
/* If there isn't, either it is unmerged, or
* resolved as "removed" by mistake. We do not
* want to do anything in the former case.
*/
pos = -pos-1;
if (pos < active_nr) {
struct cache_entry *ce = active_cache[pos];
if (ce_namelen(ce) == namelen &&
!memcmp(ce->name, path, namelen)) {
fprintf(stderr,
"%s: skipping still unmerged path.\n",
path);
goto free_return;
}
}
}
/* Grab blobs from given path from HEAD and MERGE_HEAD,
* stuff HEAD version in stage #2,
* stuff MERGE_HEAD version in stage #3.
*/
ce_2 = read_one_ent("our", head_sha1, path, namelen, 2);
ce_3 = read_one_ent("their", merge_head_sha1, path, namelen, 3);
if (!ce_2 || !ce_3) {
ret = -1;
goto free_return;
}
if (!hashcmp(ce_2->sha1, ce_3->sha1) &&
ce_2->ce_mode == ce_3->ce_mode) {
fprintf(stderr, "%s: identical in both, skipping.\n",
path);
goto free_return;
}
remove_file_from_cache(path);
if (add_cache_entry(ce_2, ADD_CACHE_OK_TO_ADD)) {
error("%s: cannot add our version to the index.", path);
ret = -1;
goto free_return;
}
if (!add_cache_entry(ce_3, ADD_CACHE_OK_TO_ADD))
return 0;
error("%s: cannot add their version to the index.", path);
ret = -1;
free_return:
free(ce_2);
free(ce_3);
return ret;
}
void stage_updated_gitmodules(void)
{
struct strbuf buf = STRBUF_INIT;
struct stat st;
int pos;
struct cache_entry *ce;
int namelen = strlen(".gitmodules");
pos = cache_name_pos(".gitmodules", namelen);
if (pos < 0) {
warning(_("could not find .gitmodules in index"));
return;
}
ce = active_cache[pos];
ce->ce_flags = namelen;
if (strbuf_read_file(&buf, ".gitmodules", 0) < 0)
die(_("reading updated .gitmodules failed"));
if (lstat(".gitmodules", &st) < 0)
die_errno(_("unable to stat updated .gitmodules"));
fill_stat_cache_info(ce, &st);
ce->ce_mode = ce_mode_from_stat(ce, st.st_mode);
if (remove_cache_entry_at(pos) < 0)
die(_("unable to remove .gitmodules from index"));
if (write_sha1_file(buf.buf, buf.len, blob_type, ce->sha1))
die(_("adding updated .gitmodules failed"));
if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE))
die(_("staging updated .gitmodules failed"));
}
static int add_cacheinfo(unsigned int mode, const struct object_id *oid,
const char *path, int stage)
{
int len, option;
struct cache_entry *ce;
if (!verify_path(path, mode))
return error("Invalid path '%s'", path);
len = strlen(path);
ce = make_empty_cache_entry(&the_index, len);
oidcpy(&ce->oid, oid);
memcpy(ce->name, path, len);
ce->ce_flags = create_ce_flags(stage);
ce->ce_namelen = len;
ce->ce_mode = create_ce_mode(mode);
if (assume_unchanged)
ce->ce_flags |= CE_VALID;
option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
if (add_cache_entry(ce, option))
return error("%s: cannot add to the index - missing --add option?",
path);
report("add '%s'", path);
return 0;
}
static int add_cacheinfo(unsigned int mode, const unsigned char *sha1,
const char *path, int stage)
{
int size, len, option;
struct cache_entry *ce;
if (!verify_path(path))
return error("Invalid path '%s'", path);
len = strlen(path);
size = cache_entry_size(len);
ce = xcalloc(1, size);
hashcpy(ce->sha1, sha1);
memcpy(ce->name, path, len);
ce->ce_flags = create_ce_flags(stage);
ce->ce_namelen = len;
ce->ce_mode = create_ce_mode(mode);
if (assume_unchanged)
ce->ce_flags |= CE_VALID;
option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
if (add_cache_entry(ce, option))
return error("%s: cannot add to the index - missing --add option?",
path);
report("add '%s'", path);
return 0;
}
static int add_one_path(const struct cache_entry *old, const char *path, int len, struct stat *st)
{
int option, size;
struct cache_entry *ce;
/* Was the old index entry already up-to-date? */
if (old && !ce_stage(old) && !ce_match_stat(old, st, 0))
return 0;
size = cache_entry_size(len);
ce = xcalloc(1, size);
memcpy(ce->name, path, len);
ce->ce_flags = create_ce_flags(0);
ce->ce_namelen = len;
fill_stat_cache_info(ce, st);
ce->ce_mode = ce_mode_from_stat(old, st->st_mode);
if (index_path(ce->sha1, path, st,
info_only ? 0 : HASH_WRITE_OBJECT)) {
free(ce);
return -1;
}
option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
if (add_cache_entry(ce, option))
return error("%s: cannot add to the index - missing --add option?", path);
return 0;
}
static void update_index_from_diff(struct diff_queue_struct *q,
struct diff_options *opt, void *data)
{
int i;
int intent_to_add = *(int *)data;
for (i = 0; i < q->nr; i++) {
struct diff_filespec *one = q->queue[i]->one;
int is_missing = !(one->mode && !is_null_sha1(one->sha1));
struct cache_entry *ce;
if (is_missing && !intent_to_add) {
remove_file_from_cache(one->path);
continue;
}
ce = make_cache_entry(one->mode, one->sha1, one->path,
0, 0);
if (!ce)
die(_("make_cache_entry failed for path '%s'"),
one->path);
if (is_missing) {
ce->ce_flags |= CE_INTENT_TO_ADD;
set_object_name_for_intent_to_add_entry(ce);
}
add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
}
}
static void update_index_from_diff(struct diff_queue_struct *q,
struct diff_options *opt, void *data)
{
int i;
int *discard_flag = data;
/* do_diff_cache() mangled the index */
discard_cache();
*discard_flag = 1;
read_cache();
for (i = 0; i < q->nr; i++) {
struct diff_filespec *one = q->queue[i]->one;
if (one->mode) {
struct cache_entry *ce;
ce = make_cache_entry(one->mode, one->sha1, one->path,
0, 0);
if (!ce)
die("make_cache_entry failed for path '%s'",
one->path);
add_cache_entry(ce, ADD_CACHE_OK_TO_ADD |
ADD_CACHE_OK_TO_REPLACE);
} else
remove_file_from_cache(one->path);
}
}
static int add_cacheinfo(unsigned int mode, const unsigned char *sha1,
const char *path, int stage, int refresh, int options)
{
struct cache_entry *ce;
ce = make_cache_entry(mode, sha1 ? sha1 : null_sha1, path, stage, refresh);
if (!ce)
return error("addinfo_cache failed for path '%s'", path);
return add_cache_entry(ce, options);
}
/******************************************************
int client: called if entry is not in cache
******************************************************/
int client(char *addr, char *message, int sock_proxy, char *URL) {
struct sockaddr_in server_addr;
char response[MAX_MSG_LENGTH];
memset(response, 0, MAX_MSG_LENGTH);
int sock;
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("Create socket error:");
return 1;
}
printf("Socket created (client)\n");
server_addr.sin_addr.s_addr = inet_addr(addr);
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(80); //convention for Internet
if (connect(sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
perror("Connect error");
return 1;
}
printf("Connected to server %s\n", addr);
//printf("////////////////////////\n%s**********************\n", message);
if (send(sock, message, MAX_MSG_LENGTH, 0) < 0) {
perror("Send error");
return 1;
}
int readlen;
char *packet = (char *)malloc(MAX_MSG_LENGTH*1024);
memset(packet, 0, MAX_MSG_LENGTH*1024);
while ((readlen = read(sock, response, sizeof(response)))!= 0){
//printf("%s", response);
strcat(packet, response);
write(sock_proxy, response, readlen);
}
//printf("%s\n", packet);
if(strstr(packet, "200 OK") != NULL){ //must be 200 response
while((cache_size+sizeof(packet)) > max_cache_size){
cache_t *temp = cache;
cache = cache->next;
cache_size -= temp->length;
//free(temp);
}
printf("\n\n\nmax: %i current: %i\n\n\n", max_cache_size, cache_size);
add_cache_entry(&cache, packet, URL);
cache_size += (int)strlen(packet);
}
//free(packet);
return 0;
}
static void update_index_from_diff(struct diff_queue_struct *q,
struct diff_options *opt, void *data)
{
int i;
for (i = 0; i < q->nr; i++) {
struct diff_filespec *one = q->queue[i]->one;
if (one->mode && !is_null_sha1(one->sha1)) {
struct cache_entry *ce;
ce = make_cache_entry(one->mode, one->sha1, one->path,
0, 0);
if (!ce)
die(_("make_cache_entry failed for path '%s'"),
one->path);
add_cache_entry(ce, ADD_CACHE_OK_TO_ADD |
ADD_CACHE_OK_TO_REPLACE);
} else
remove_file_from_cache(one->path);
}
}
static int read_one_entry_opt(const unsigned char *sha1, const char *base, int baselen, const char *pathname, unsigned mode, int stage, int opt)
{
int len;
unsigned int size;
struct cache_entry *ce;
if (S_ISDIR(mode))
return READ_TREE_RECURSIVE;
len = strlen(pathname);
size = cache_entry_size(baselen + len);
ce = xcalloc(1, size);
ce->ce_mode = create_ce_mode(mode);
ce->ce_flags = create_ce_flags(baselen + len, stage);
memcpy(ce->name, base, baselen);
memcpy(ce->name + baselen, pathname, len+1);
hashcpy(ce->sha1, sha1);
return add_cache_entry(ce, opt);
}
static void
cogl_gst_yv12_glsl_setup_pipeline (CoglGstVideoSink *sink,
CoglPipeline *pipeline)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
static SnippetCache snippet_cache;
SnippetCacheEntry *entry;
entry = get_cache_entry (sink, &snippet_cache);
if (entry == NULL)
{
char *source;
source =
g_strdup_printf ("vec4\n"
"cogl_gst_sample_video%i (vec2 UV)\n"
"{\n"
" float y = 1.1640625 * "
"(texture2D (cogl_sampler%i, UV).a - 0.0625);\n"
" float u = texture2D (cogl_sampler%i, UV).a - 0.5;\n"
" float v = texture2D (cogl_sampler%i, UV).a - 0.5;\n"
" vec4 color;\n"
" color.r = y + 1.59765625 * v;\n"
" color.g = y - 0.390625 * u - 0.8125 * v;\n"
" color.b = y + 2.015625 * u;\n"
" color.a = 1.0;\n"
" return color;\n"
"}\n",
priv->custom_start,
priv->custom_start,
priv->custom_start + 1,
priv->custom_start + 2);
entry = add_cache_entry (sink, &snippet_cache, source);
g_free (source);
}
setup_pipeline_from_cache_entry (sink, pipeline, entry, 3);
}
static int add_file_to_cache(char *path)
{
int size, namelen;
struct cache_entry *ce;
struct stat st;
int fd;
fd = open(path, O_RDONLY);
if (fd < 0) {
if (errno == ENOENT)
return remove_file_from_cache(path);
return -1;
}
if (fstat(fd, &st) < 0) {
close(fd);
return -1;
}
namelen = strlen(path);
size = cache_entry_size(namelen);
ce = malloc(size);
memset(ce, 0, size);
memcpy(ce->name, path, namelen);
ce->ctime.sec = st.st_ctime;
ce->ctime.nsec = st.st_ctim.tv_nsec;
ce->mtime.sec = st.st_mtime;
ce->mtime.nsec = st.st_mtim.tv_nsec;
ce->st_dev = st.st_dev;
ce->st_ino = st.st_ino;
ce->st_mode = st.st_mode;
ce->st_uid = st.st_uid;
ce->st_gid = st.st_gid;
ce->st_size = st.st_size;
ce->namelen = namelen;
if (index_fd(path, namelen, ce, fd, &st) < 0)
return -1;
return add_cache_entry(ce);
}
static int update_some(const struct object_id *oid, struct strbuf *base,
const char *pathname, unsigned mode, int stage, void *context)
{
int len;
struct cache_entry *ce;
int pos;
if (S_ISDIR(mode))
return READ_TREE_RECURSIVE;
len = base->len + strlen(pathname);
ce = make_empty_cache_entry(&the_index, len);
oidcpy(&ce->oid, oid);
memcpy(ce->name, base->buf, base->len);
memcpy(ce->name + base->len, pathname, len - base->len);
ce->ce_flags = create_ce_flags(0) | CE_UPDATE;
ce->ce_namelen = len;
ce->ce_mode = create_ce_mode(mode);
/*
* If the entry is the same as the current index, we can leave the old
* entry in place. Whether it is UPTODATE or not, checkout_entry will
* do the right thing.
*/
pos = cache_name_pos(ce->name, ce->ce_namelen);
if (pos >= 0) {
struct cache_entry *old = active_cache[pos];
if (ce->ce_mode == old->ce_mode &&
oideq(&ce->oid, &old->oid)) {
old->ce_flags |= CE_UPDATE;
discard_cache_entry(ce);
return 0;
}
}
add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
return 0;
}
/*******************************************************************
* Adds information from received ARP Reply to ARP Cache and returns newly added ARP Cache entry.
*******************************************************************/
struct arp_cache_entry* got_Reply(struct packet_state * ps, struct sr_arphdr * arp)
{
add_cache_entry(ps, arp->ar_sip, arp->ar_sha); /*Add IP and MAC address from reply to cache */
return search_cache(ps, arp->ar_sip); /*Return the newly added entry. */
}
/* Implements message handlers for the front-end server.
* Responds to messages:
* echo
* heartbeat
* client
* query
* invalidate */
int read_msg(char *src, char *Instr, char *Arg1, char *Arg2)
{
char instr[CONTENT_MAX];
char arg1[CONTENT_MAX];
char arg2[CONTENT_MAX];
strcpy(instr,Instr);
strcpy(arg1,Arg1);
strcpy(arg2,Arg2);
/* If we've received a heartbeat from our neighbor, reset the beat counter */
if(heartbeat(instr))
{
pthread_mutex_lock(&heart);
beat_count = 0;
pthread_mutex_unlock(&heart);
char h_msg[CONTENT_MAX];
sprintf(h_msg,"%s,%d,NULL",hea,server_id);
message_host(neighbor_addr,h_msg);
return 0;
}
/* Register all clients with both front-end servers */
if(client(instr))
{
// update client cache
printf("client update: %s,%s,%s\n",instr,arg1,arg2);
struct cache_entry *client;
unsigned int c_id;
inet_pton(AF_INET,arg1,&c_id);
if( (client = found(c_id,clients))==NULL)
{
client = new_cache_entry(c_id,arg1);
client->server_id = atoi(arg2);
add_cache_entry(SORTED,client,clients);
}
print_cache(clients);
}
/* When we receive a query from a client, first check to see if we
* have the result cached locally. If not, store the request and
* query the database. The request will be serviced once the database
* has responded */
if(query(instr))
{
printf("Servicing client [%s] request for [%s:%s]\n",
src,arg1,arg2);
// first check and see if we have the query in our local cache
struct cache_entry *result;
int q_id = create_cache_id(arg1,arg2,NULL);
//printf("new q_id: %d\n",q_id);
result = found(q_id,cache);
// if we don't have it, request entry from database
if(result == NULL)
{
printf("Entry not found. Checking Database [%s]\n",database_addr);
char request[CONTENT_MAX];
sprintf(request,"%s,%s,%s",que,arg1,arg2);
message_host(database_addr,request);
}
else
{
// we can respond right away!
printf("FOUND! Returning result to client...\n");
char msg[CONTENT_MAX];
sprintf(msg,"%s,%s,%s",arg1,arg2,result->value);
message_host(src,msg);
return 0;
}
// add client to service queue - will be handled when we get db response
//printf("add client to service queue.\n");
add_cache_entry(SORTED,new_cache_entry(q_id,src),pending_queries);
return 0;
}
/* If the database is pushing updates, the front-end server will replace
* outdated entries when told to */
if(invalidate(instr))
{
printf("Replacing old entry for [%s:%s]\n",arg1,arg2);
int q_id = create_cache_id(instr,arg1,arg2);
invalidate_cache(q_id,cache);
//printf("Invalidate entry [%d] => \n",q_id);
//print_cache(cache);
char message[CONTENT_MAX];
sprintf(message,"%s,%s,%s",que,arg1,arg2);
message_host(src,message);
return 0;
}
/* Used to register new clients when they boot up */
if(echo(instr))
{
// update client cache
printf("register new client: %s,%s\n",instr,arg1);
struct cache_entry *client;
unsigned int c_id;
inet_pton(AF_INET,arg1,&c_id);
if( (client = found(c_id,clients))==NULL)
{
client = new_cache_entry(c_id,arg1);
client->server_id = server_id;
add_cache_entry(SORTED,client,clients);
}
print_cache(clients);
// notify other Frontend server
printf("Notifying neighbor: %s\n",neighbor_addr);
char c_msg[CONTENT_MAX];
sprintf(c_msg,"%s,%s,%d",cli,src,server_id);
message_host(neighbor_addr,c_msg);
return 0;
}
// query response
int q_id = create_cache_id(instr,arg1,arg2);
struct cache_entry *f;
if( (f=found(q_id,cache))==NULL)
add_cache_entry(SORTED,new_cache_entry(q_id,arg2),cache);
else if( (f!=NULL) && strcmp(f->value,arg2) != 0)
{
// if we have an update, replace the old entry
printf("Replacing old entry for [%s:%s]\n",arg1,arg2);
delete_entry(f,cache);
add_cache_entry(SORTED,new_cache_entry(q_id,arg2),cache);
}
//print_cache(cache);
// if we have a client waiting for this query, respond
struct cache_entry *pending_client;
//print_cache(pending_queries);
while( (pending_client = found(q_id,pending_queries)) != NULL)
{
printf("Database returned entry [%s:%s]. Responding to client [%s]\n",
arg1,arg2,pending_client->value);
//printf("next client->%s\n",pending_client->value);
char msg[CONTENT_MAX];
sprintf(msg,"%s,%s,%s",instr,arg1,arg2);
message_host(pending_client->value,msg);
delete_entry(pending_client,pending_queries);
}
return 0;
}
/*
* Prepare a dummy commit that represents the work tree (or staged) item.
* Note that annotating work tree item never works in the reverse.
*/
static struct commit *fake_working_tree_commit(struct diff_options *opt,
const char *path,
const char *contents_from)
{
struct commit *commit;
struct blame_origin *origin;
struct commit_list **parent_tail, *parent;
struct object_id head_oid;
struct strbuf buf = STRBUF_INIT;
const char *ident;
time_t now;
int size, len;
struct cache_entry *ce;
unsigned mode;
struct strbuf msg = STRBUF_INIT;
read_cache();
time(&now);
commit = alloc_commit_node();
commit->object.parsed = 1;
commit->date = now;
parent_tail = &commit->parents;
if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, head_oid.hash, NULL))
die("no such ref: HEAD");
parent_tail = append_parent(parent_tail, &head_oid);
append_merge_parents(parent_tail);
verify_working_tree_path(commit, path);
origin = make_origin(commit, path);
ident = fmt_ident("Not Committed Yet", "not.committed.yet", NULL, 0);
strbuf_addstr(&msg, "tree 0000000000000000000000000000000000000000\n");
for (parent = commit->parents; parent; parent = parent->next)
strbuf_addf(&msg, "parent %s\n",
oid_to_hex(&parent->item->object.oid));
strbuf_addf(&msg,
"author %s\n"
"committer %s\n\n"
"Version of %s from %s\n",
ident, ident, path,
(!contents_from ? path :
(!strcmp(contents_from, "-") ? "standard input" : contents_from)));
set_commit_buffer_from_strbuf(commit, &msg);
if (!contents_from || strcmp("-", contents_from)) {
struct stat st;
const char *read_from;
char *buf_ptr;
unsigned long buf_len;
if (contents_from) {
if (stat(contents_from, &st) < 0)
die_errno("Cannot stat '%s'", contents_from);
read_from = contents_from;
}
else {
if (lstat(path, &st) < 0)
die_errno("Cannot lstat '%s'", path);
read_from = path;
}
mode = canon_mode(st.st_mode);
switch (st.st_mode & S_IFMT) {
case S_IFREG:
if (DIFF_OPT_TST(opt, ALLOW_TEXTCONV) &&
textconv_object(read_from, mode, &null_oid, 0, &buf_ptr, &buf_len))
strbuf_attach(&buf, buf_ptr, buf_len, buf_len + 1);
else if (strbuf_read_file(&buf, read_from, st.st_size) != st.st_size)
die_errno("cannot open or read '%s'", read_from);
break;
case S_IFLNK:
if (strbuf_readlink(&buf, read_from, st.st_size) < 0)
die_errno("cannot readlink '%s'", read_from);
break;
default:
die("unsupported file type %s", read_from);
}
}
else {
/* Reading from stdin */
mode = 0;
if (strbuf_read(&buf, 0, 0) < 0)
die_errno("failed to read from stdin");
}
convert_to_git(path, buf.buf, buf.len, &buf, 0);
origin->file.ptr = buf.buf;
origin->file.size = buf.len;
pretend_sha1_file(buf.buf, buf.len, OBJ_BLOB, origin->blob_oid.hash);
/*
* Read the current index, replace the path entry with
* origin->blob_sha1 without mucking with its mode or type
* bits; we are not going to write this index out -- we just
* want to run "diff-index --cached".
*/
discard_cache();
read_cache();
len = strlen(path);
if (!mode) {
int pos = cache_name_pos(path, len);
if (0 <= pos)
mode = active_cache[pos]->ce_mode;
else
/* Let's not bother reading from HEAD tree */
mode = S_IFREG | 0644;
}
size = cache_entry_size(len);
ce = xcalloc(1, size);
oidcpy(&ce->oid, &origin->blob_oid);
memcpy(ce->name, path, len);
ce->ce_flags = create_ce_flags(0);
ce->ce_namelen = len;
ce->ce_mode = create_ce_mode(mode);
add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);
cache_tree_invalidate_path(&the_index, path);
return commit;
}
void add_to_cache(dlinklist* arp_cache, const uint8_t *const packet)
{
struct sr_arphdr *arp = (struct sr_arphdr *) (packet + sizeof(struct sr_ethernet_hdr));
add_cache_entry(arp_cache, arp->ar_sip, arp->ar_sha);
}
int mydisk_read(int start_address, int nbytes, void *buffer) {
//TODO:
//startBlockIdx and endBlockIdx indicate start and end block
//of this writing operation
//pls carefully calculate them
int startBlockIdx = 0;
int endBlockIdx = 0;
int i = 0, j = 0;
int iEndAddress = start_address + nbytes -1;
int iCurrPosition = 0;
int iNumberOfBlocks;
char *cCache = (char *)malloc(BLOCK_SIZE);
int bSeek = 0;
startBlockIdx = start_address / BLOCK_SIZE;
endBlockIdx = (start_address + nbytes - 1) / BLOCK_SIZE;
iNumberOfBlocks = endBlockIdx - startBlockIdx + 1;
// Validating that the parameters are good for the operation.
if (start_address < 0) {
return (1);
} else if (nbytes < 0) {
return (1);
} else if ((start_address + nbytes) >= (diskEntity.max_blocks*BLOCK_SIZE) ) {
return (1);
}
size_t bufferOffset = 0;
for (i = startBlockIdx; i < endBlockIdx + 1; i++) {
int blockInCacheFlag = 0; //0 - no, 1 - yes
if (1 == CACHE_SWITCH) blockInCacheFlag = query_cache(i);
// The time required to move between sector for the first block.
if ((diskEntity.disk_type == 0) && !blockInCacheFlag && !bSeek) {
Disk_Latency += HDD_SEEK;
bSeek = 1;
}
if (0 == blockInCacheFlag) {
//if cache is missed or disabled
//TODO:read data from disk
// Calculation for the disk latency for each block.
if (diskEntity.disk_type == 0) {
Disk_Latency += HDD_READ_LATENCY;
} else if (diskEntity.disk_type == 1) {
Disk_Latency += SSD_READ_LATENCY;
}
for (j = 0 ; j < BLOCK_SIZE; j++) {
iCurrPosition = i*BLOCK_SIZE+j;
if ((iCurrPosition >= start_address) && (iCurrPosition <= iEndAddress)) {
fseek(diskEntity.pBlockStore, iCurrPosition, SEEK_SET);
fread(buffer+bufferOffset, 1, 1, diskEntity.pBlockStore);
// Add the content in "cCache" to have a full block of information.
bufferOffset++;
}
}
if (1 == CACHE_SWITCH) {
// Add the latency for the caching.
if (diskEntity.disk_type == 0) {
Disk_Latency += CACHE_WRITE_LATENCY;
} else if (diskEntity.disk_type == 1) {
Disk_Latency += CACHE_WRITE_LATENCY;
}
// Reading the data on the disk to have the full block in the cache.
for (j = 0 ; j < BLOCK_SIZE; j++) {
iCurrPosition = i*BLOCK_SIZE+j;
if ((iCurrPosition >= start_address) && (iCurrPosition <= iEndAddress)) {
// Add the content in "cCache" to have a full block of information.
fseek (diskEntity.pBlockStore, iCurrPosition, SEEK_SET);
fread(cCache+j, 1, 1, diskEntity.pBlockStore);
} else {
// Will read and store the part of the block which is not in the passed buffer
// to have a complete block in the cache.
fseek (diskEntity.pBlockStore, iCurrPosition, SEEK_SET);
fread(cCache+j, 1, 1, diskEntity.pBlockStore);
}
}
//TODO: if cache is enabled, cache this block
add_cache_entry(i, cCache);
cCache = (char *)malloc(BLOCK_SIZE);
}
} else {
Disk_Latency += CACHE_READ_LATENCY;
//if this block is cached,
//TODO:read this block from cache through read_cache(int)
char *cCachedBlock = read_cache(i);
for (j = 0 ; j < BLOCK_SIZE ; j++) {
iCurrPosition = i*BLOCK_SIZE+j;
if ((iCurrPosition >= start_address) && (iCurrPosition <= iEndAddress)) {
memset(buffer+bufferOffset, cCachedBlock[j], 1);
bufferOffset++;
}
}
}
//TODO:copy the data into the buffer[
//take care about the offsets
}
return 0;
}
int mydisk_write(int start_address, int nbytes, void *buffer) {
//TODO:
//startBlockIdx and endBlockIdx indicate start and end block
//of this writing operation
//pls carefully calculate them
int startBlockIdx = 0;
int endBlockIdx = 0;
int i = 0, iBufferTarget = 0, j = 0;
int iEndAddress = start_address + nbytes -1;
int iCurrPosition = 0;
int iNumberOfBlocks;
char *cCache = (char *)malloc(BLOCK_SIZE);
int bSeek = 0;
//printf("*** mydisk_write(%i, %i, %s), buffersize(%i)\n",start_address, nbytes, buffer, strlen(buffer));
startBlockIdx = start_address / BLOCK_SIZE;
endBlockIdx = (start_address + nbytes - 1) / BLOCK_SIZE;
iNumberOfBlocks = endBlockIdx - startBlockIdx + 1;
// Validating that the parameters are good for the operation.
if (start_address < 0) {
return (1);
} else if (nbytes < 0) {
return (1);
} else if ((start_address + nbytes) >= (diskEntity.max_blocks*BLOCK_SIZE) ) {
return (1);
}
for (i = startBlockIdx; i < endBlockIdx + 1; i++) {
//TODO:write block by block
//be careful for some extreme case
//e.g. start_address and start_address are not start or end of a block
// The code under is for when the cache is enabled.
int blockInCacheFlag = 0; //0 - no, 1 - yes
//check if the current block is cached
if (1 == CACHE_SWITCH) blockInCacheFlag = query_cache(i);
// The time required to move between sector for the first block.
if ((diskEntity.disk_type == 0) && !blockInCacheFlag && !bSeek) {
//printf("----- (Seek sector): 1S\n");
Disk_Latency += HDD_SEEK;
bSeek = 1;
}
if (0 == blockInCacheFlag) {
// Calculation for the disk latency for each block.
if (diskEntity.disk_type == 0) {
Disk_Latency += HDD_WRITE_LATENCY;
} else if (diskEntity.disk_type == 1) {
Disk_Latency += SSD_WRITE_LATENCY;
}
//TODO:write data into the disk
for (j = 0 ; j < BLOCK_SIZE; j++) {
iCurrPosition = i*BLOCK_SIZE+j;
if ((iCurrPosition >= start_address) && (iCurrPosition <= iEndAddress)) {
fseek (diskEntity.pBlockStore, iCurrPosition, SEEK_SET);
fwrite(buffer+iBufferTarget, 1, 1, diskEntity.pBlockStore);
iBufferTarget++;
}
}
//TODO:if cache is enabled, cache current block
if (1 == CACHE_SWITCH) {
// Add the latency for the caching.
if (diskEntity.disk_type == 0) {
Disk_Latency += HDD_SEEK + HDD_READ_LATENCY + CACHE_WRITE_LATENCY;
} else if (diskEntity.disk_type == 1) {
Disk_Latency += SSD_READ_LATENCY + CACHE_WRITE_LATENCY;
}
// Reading the data on the disk to have the full block in the cache.
for (j = 0 ; j < BLOCK_SIZE; j++) {
iCurrPosition = i*BLOCK_SIZE+j;
if ((iCurrPosition >= start_address) && (iCurrPosition <= iEndAddress)) {
// Add the content in "cCache" to have a full block of information.
fseek (diskEntity.pBlockStore, iCurrPosition, SEEK_SET);
fread(cCache+j, 1, 1, diskEntity.pBlockStore);
} else {
// Will read and store the part of the block which is not in the passed buffer
// to have a complete block in the cache.
fseek (diskEntity.pBlockStore, iCurrPosition, SEEK_SET);
fread(cCache+j, 1, 1, diskEntity.pBlockStore);
}
}
add_cache_entry(i, cCache);
// Reset the memory.
cCache = (char *)malloc(BLOCK_SIZE);
}
}//if yes, write the new content into the cache,
//and make the dirty flag of cached blk to be 1
else {
//TODO: if current block is cached,
//then modify the data in cache and mark it as dirty
size_t blkOffset = 0;
size_t contentSize = 0;
char *block_data = (char *) malloc(BLOCK_SIZE);
// Setting the offset from the start of the block.
if (start_address > (i * BLOCK_SIZE)) {
blkOffset = start_address - (i * BLOCK_SIZE);
} else {
blkOffset = 0;
}
// Setting the number of bits to update in the cache.
if ((start_address + nbytes) < ((i + 1) * BLOCK_SIZE)) {
contentSize = BLOCK_SIZE - blkOffset - (((i + 1) * BLOCK_SIZE) - (start_address + nbytes));
} else {
contentSize = BLOCK_SIZE - blkOffset;
}
// Determining "data_block" to pass it in the function.
for (j = 0; j < BLOCK_SIZE; j++) {
iCurrPosition = i * BLOCK_SIZE + j;
if ((iCurrPosition >= start_address) && (iCurrPosition <= iEndAddress)) {
fwrite(buffer + iBufferTarget, 1, 1, diskEntity.pBlockStore);
block_data[j] = *((char*) buffer + iBufferTarget);
iBufferTarget++;
}
}
write_cache(i, block_data, blkOffset, contentSize);
Disk_Latency += CACHE_WRITE_LATENCY;
}
}
return 0;
}
int read_msg(char *src, char *Instr, char *Arg1, char *Arg2)
{
//printf("Received: FROM => %s\tCMD => %s,%s,%s\n",src,Instr,Arg1,Arg2);
char instr[CONTENT_MAX];
char arg1[CONTENT_MAX];
char arg2[CONTENT_MAX];
strcpy(instr,Instr);
strcpy(arg1,Arg1);
strcpy(arg2,Arg2);
if(echo(instr))
{
message_host(src,"echo,NULL,NULL");
}
/* Database will immediately notify its registered clients if local data
* has been updated, only when the database is configured to PUSH updates
* with the command line flag -p */
else if(incr(instr))
{
if(PUSH_UPDATES)
{
// send invalidation msg to all known clients
struct cache_entry *client;
int index=0;
/* Iterates over all saved clients */
for(index=0;index<clients_cache->length;index++)
{
client = get_index(index,clients_cache);
printf("Pushing updates to client [%s]\n",client->value);
char msg[CONTENT_MAX];
sprintf(msg,"%s,%s,%s",inv,arg1,arg2);
message_host(client->value,msg);
}
}
/* Routine for updating local data */
if(rome(arg1))
{
if(gold(arg2))
{
r.gold++;
}
if(silver(arg2))
{
r.silver++;
}
if(bronze(arg2))
{
r.bronze++;
}
if(tennis(arg2))
{
score_tennis.rome_score++;
}
if(soccer(arg2))
{
score_soccer.rome_score++;
}
if(frisbee(arg2))
{
score_frisbee.rome_score++;
}
}
if(gaul(arg1))
{
if(gold(arg2))
{
g.gold++;
}
if(silver(arg2))
{
g.silver++;
}
if(bronze(arg2))
{
g.bronze++;
}
if(tennis(arg2))
{
score_tennis.gaul_score++;
}
if(soccer(arg2))
{
score_soccer.gaul_score++;
}
if(frisbee(arg2))
{
score_frisbee.gaul_score++;
}
}
/* Display updates on the terminal screen */
printf("Update received -------------------------\n"
"Gaul >> Gold %d, Silver %d, Bronze %d\n"
"Rome >> Gold %d, Silver %d, Bronze %d\n"
"--------------------------------------------\n"
"Tennis: Gaul %d | Rome %d\n"
"Frisbee: Gaul %d | Rome %d\n"
"Soccer: Gaul %d | Rome %d\n",
r.gold, r.silver, r.bronze,
g.gold, g.silver, g.bronze,
score_tennis.gaul_score, score_tennis.rome_score,
score_frisbee.gaul_score, score_frisbee.rome_score,
score_soccer.gaul_score, score_soccer.rome_score);
}
/* Service client query */
else if(query(instr))
{
// when a front-end server queries for the first time, add it to the
// cache of known hosts
printf("Responding to query [%s:%s] from client [%s]\n",
arg1,arg2,src);
while(clients_cache==NULL); // wait for client cache to come online
struct cache_entry *connected_client;
unsigned int client_id;
inet_pton(AF_INET,src,&client_id);
connected_client = new_cache_entry(client_id,src);
if(!found(client_id,clients_cache))
add_cache_entry(SORTED,connected_client,clients_cache);
/* Build query response */
char response[100];
if(rome(arg1))
{
if(gold(arg2))
{
sprintf(response,"rome,gold,%d",r.gold);
}
if(silver(arg2))
{
sprintf(response,"rome,silver,%d",r.silver);
}
if(bronze(arg2))
{
sprintf(response,"rome,bronze,%d",r.bronze);
}
if(tennis(arg2))
{
sprintf(response,"rome,tennis,%d",score_tennis.rome_score);
}
if(soccer(arg2))
{
sprintf(response,"rome,soccer,%d",score_soccer.rome_score);
}
if(frisbee(arg2))
{
sprintf(response,"rome,frisbee,%d",score_frisbee.rome_score);
}
}
if(gaul(arg1))
{
if(gold(arg2))
{
sprintf(response,"gaul,gold,%d",r.gold);
}
if(silver(arg2))
{
sprintf(response,"gaul,silver,%d",r.silver);
}
if(bronze(arg2))
{
sprintf(response,"gaul,bronze,%d",r.bronze);
}
if(tennis(arg2))
{
sprintf(response,"gaul,tennis,%d",score_tennis.gaul_score);
}
if(soccer(arg2))
{
sprintf(response,"gaul,soccer,%d",score_soccer.gaul_score);
}
if(frisbee(arg2))
{
sprintf(response,"gaul,frisbee,%d",score_soccer.gaul_score);
}
}
printf("Responding to %s\n",src);
message_host(src,response);
}
return 0;
}
