static int send_reply(fuse_req_t req, int error, const void *arg,
size_t argsize)
{
struct fuse_out_header out;
struct iovec iov[2];
size_t count;
int res;
if (error <= -1000 || error > 0) {
fprintf(stderr, "fuse: bad error value: %i\n", error);
error = -ERANGE;
}
out.unique = req->unique;
out.error = error;
count = 1;
iov[0].iov_base = &out;
iov[0].iov_len = sizeof(struct fuse_out_header);
if (argsize && !error) {
count++;
iov[1].iov_base = (void *) arg;
iov[1].iov_len = argsize;
}
out.len = iov_length(iov, count);
if (req->f->debug) {
printf(" unique: %llu, error: %i (%s), outsize: %i\n",
out.unique, out.error, strerror(-out.error), out.len);
fflush(stdout);
}
res = fuse_chan_send(req->ch, iov, count);
free_req(req);
return res;
}
static int send_reply_iov(fuse_req_t req, int error, struct iovec *iov,
int count)
{
struct fuse_out_header out;
int res;
if (error <= -1000 || error > 0) {
fprintf(stderr, "fuse: bad error value: %i\n", error);
error = -ERANGE;
}
out.unique = req->unique;
out.error = error;
iov[0].iov_base = &out;
iov[0].iov_len = sizeof(struct fuse_out_header);
out.len = iov_length(iov, count);
/* Foxconn removed start pling 06/19/2009 */
#if 0
if (req->f->debug)
fprintf(stderr, " unique: %llu, error: %i (%s), outsize: %i\n",
(unsigned long long) out.unique, out.error,
strerror(-out.error), out.len);
#endif
/* Foxconn removed end pling 06/19/2009 */
res = fuse_chan_send(req->ch, iov, count);
free_req(req);
return res;
}
static void FUNCTION_ATTRIBUTE
http_exit(HTTP_RESULT http_result)
{
http_flag = 0;
PRINTF("htt_result:%d\n", http_result);
free_req();
if(HTTP_TIMEOUT == http_result)
{
PRINTF("http time out!\n");
free_http_buf();
free_conn();
user_cb(NULL);
}
else
{
os_timer_disarm(&timeout_timer);
}
if(DNS_FAIL == http_result)
{
free_http_buf();
user_cb(NULL);
}
else if(HTTP_ERR == http_result)
{
free_http_buf();
free_conn();
user_cb(NULL);
}
if(HTTP_OK == http_result)
{
free_conn();
const char * version = "HTTP/1.1 ";
if (os_strncmp(http_buf->buffer, version, os_strlen(version)) != 0)
{
PRINTF("Invalid version in %s\n", http_buf->buffer);
return;
}
int http_status = atoi(http_buf->buffer + os_strlen(version));
char * body = (char *)os_strstr(http_buf->buffer, "\r\n\r\n") + 4;
if (user_cb != NULL)
{
// Callback is optional.
user_cb(body);
}
free_http_buf();
}
}
static void hptiop_host_request_callback(struct hptiop_hba *hba, u32 tag)
{
struct hpt_iop_request_scsi_command *req;
struct scsi_cmnd *scp;
req = (struct hpt_iop_request_scsi_command *)hba->reqs[tag].req_virt;
dprintk("hptiop_host_request_callback: req=%p, type=%d, "
"result=%d, context=0x%x tag=%d\n",
req, req->header.type, req->header.result,
req->header.context, tag);
BUG_ON(!req->header.result);
BUG_ON(req->header.type != cpu_to_le32(IOP_REQUEST_TYPE_SCSI_COMMAND));
scp = hba->reqs[tag].scp;
if (HPT_SCP(scp)->mapped)
scsi_dma_unmap(scp);
switch (le32_to_cpu(req->header.result)) {
case IOP_RESULT_SUCCESS:
scp->result = (DID_OK<<16);
break;
case IOP_RESULT_BAD_TARGET:
scp->result = (DID_BAD_TARGET<<16);
break;
case IOP_RESULT_BUSY:
scp->result = (DID_BUS_BUSY<<16);
break;
case IOP_RESULT_RESET:
scp->result = (DID_RESET<<16);
break;
case IOP_RESULT_FAIL:
scp->result = (DID_ERROR<<16);
break;
case IOP_RESULT_INVALID_REQUEST:
scp->result = (DID_ABORT<<16);
break;
case IOP_RESULT_MODE_SENSE_CHECK_CONDITION:
scp->result = SAM_STAT_CHECK_CONDITION;
memset(&scp->sense_buffer,
0, sizeof(scp->sense_buffer));
memcpy(&scp->sense_buffer, &req->sg_list,
min(sizeof(scp->sense_buffer),
le32_to_cpu(req->dataxfer_length)));
break;
default:
scp->result = ((DRIVER_INVALID|SUGGEST_ABORT)<<24) |
(DID_ABORT<<16);
break;
}
dprintk("scsi_done(%p)\n", scp);
scp->scsi_done(scp);
free_req(hba, &hba->reqs[tag]);
}
static void discard_req(h2o_memcached_req_t *req)
{
switch (req->type) {
case REQ_TYPE_GET:
h2o_multithread_send_message(req->data.get.receiver, &req->data.get.message);
break;
default:
free_req(req);
break;
}
}
void h2o_memcached_cancel_get(h2o_memcached_context_t *ctx, h2o_memcached_req_t *req)
{
int do_free = 0;
pthread_mutex_lock(&ctx->mutex);
req->data.get.cb = NULL;
if (h2o_linklist_is_linked(&req->pending)) {
h2o_linklist_unlink(&req->pending);
do_free = 1;
}
pthread_mutex_unlock(&ctx->mutex);
if (do_free)
free_req(req);
}
void h2o_memcached_receiver(h2o_multithread_receiver_t *receiver, h2o_linklist_t *messages)
{
while (!h2o_linklist_is_empty(messages)) {
h2o_memcached_req_t *req = H2O_STRUCT_FROM_MEMBER(h2o_memcached_req_t, data.get.message.link, messages->next);
h2o_linklist_unlink(&req->data.get.message.link);
assert(req->type == REQ_TYPE_GET);
if (req->data.get.cb != NULL) {
if (req->data.get.value_is_encoded && req->data.get.value.len != 0) {
h2o_iovec_t decoded = h2o_decode_base64url(NULL, req->data.get.value.base, req->data.get.value.len);
h2o_mem_set_secure(req->data.get.value.base, 0, req->data.get.value.len);
free(req->data.get.value.base);
req->data.get.value = decoded;
}
req->data.get.cb(req->data.get.value, req->data.get.cb_data);
}
free_req(req);
}
}
/* Consumes connection file descriptors from the shared buffer and
* processes them.
*/
void *thread(void *vargp){
// avoid memory leak
Pthread_detach(pthread_self());
req_t request;
int result;
while(1){
int connfd = sbuf_remove(&sbuf);
if((result = process_request(connfd, &request)) == -1){
fprintf(stderr,"process_request failed\n");
bad_request(connfd);
free_req(request);
Close(connfd);
continue;
}
forward_request(connfd, request);
Close(connfd);
}
}
void check_reqs() {
while (reqs) {
int val = reqs->status;
if (val != BUSY) {
enum atypes type = (reqs->type);
reqs->type = done;
switch (type) {
case aread:
handle_read(reqs);
break;
case awrite:
handle_write(reqs);
break;
#ifdef F_ASYNC_GETDIR
case agetdir:
handle_getdir(reqs);
break;
#endif
#ifdef F_ASYNC_DB_EXEC
case adbexec:
handle_db_exec(reqs);
break;
#endif
case done:
//must have had an error while handling it before.
break;
default:
fatal("unknown async type\n");
}
struct request *here = reqs;
reqs = reqs->next;
if(!reqs)
lastreq = reqs;
free_funp(here->fun->f.fp);
free_cb(here->fun);
free_req(here);
} else
return;
}
}
//
// The function to handle a client connection
//
void handle_connection(int fd)
{
http_req req;
FILE *rx, *tx;
exit_msg((fd < 0) || (fd > FD_SETSIZE), "bad fd");
// for streams with sockets, need one for read and one for write
rx = fdopen(fd, "r");
tx = fdopen(dup(fd), "w");
init_req(&req);
http_get_request(rx, &req);
http_process_request(&req);
http_response(tx, &req);
shutdown(fileno(rx), SHUT_RDWR);
fclose(rx);
fclose(tx);
free_req(&req);
return;
}
void fuse_reply_none(fuse_req_t req)
{
fuse_chan_send(req->ch, NULL, 0);
free_req(req);
}
static int
write_read_e2e_dp_tests(struct dev *dev, nvme_build_io_req_fn_t build_io_fn, const char *test_name)
{
int rc = 0;
uint32_t lba_count;
uint32_t io_flags = 0;
struct io_request *req;
struct spdk_nvme_ns *ns;
struct spdk_nvme_qpair *qpair;
const struct spdk_nvme_ns_data *nsdata;
ns = spdk_nvme_ctrlr_get_ns(dev->ctrlr, 1);
if (!ns) {
fprintf(stderr, "Null namespace\n");
return 0;
}
if (!(spdk_nvme_ns_get_flags(ns) & SPDK_NVME_NS_DPS_PI_SUPPORTED))
return 0;
nsdata = spdk_nvme_ns_get_data(ns);
if (!nsdata || !spdk_nvme_ns_get_sector_size(ns)) {
fprintf(stderr, "Empty nsdata or wrong sector size\n");
return 0;
}
req = rte_zmalloc(NULL, sizeof(*req), 0);
if (!req) {
fprintf(stderr, "Allocate request failed\n");
return 0;
}
/* IO parameters setting */
lba_count = build_io_fn(ns, req, &io_flags);
if (!lba_count) {
fprintf(stderr, "%s: %s bypass the test case\n", dev->name, test_name);
free_req(req);
return 0;
}
qpair = spdk_nvme_ctrlr_alloc_io_qpair(dev->ctrlr, 0);
if (!qpair) {
free_req(req);
return -1;
}
ns_data_buffer_reset(ns, req, DATA_PATTERN);
if (req->use_extended_lba)
rc = spdk_nvme_ns_cmd_write(ns, qpair, req->contig, req->lba, lba_count,
io_complete, req, io_flags);
else
rc = spdk_nvme_ns_cmd_write_with_md(ns, qpair, req->contig, req->metadata, req->lba, lba_count,
io_complete, req, io_flags, req->apptag_mask, req->apptag);
if (rc != 0) {
fprintf(stderr, "%s: %s write submit failed\n", dev->name, test_name);
spdk_nvme_ctrlr_free_io_qpair(qpair);
free_req(req);
return -1;
}
io_complete_flag = 0;
while (!io_complete_flag)
spdk_nvme_qpair_process_completions(qpair, 1);
if (io_complete_flag != 1) {
fprintf(stderr, "%s: %s write exec failed\n", dev->name, test_name);
spdk_nvme_ctrlr_free_io_qpair(qpair);
free_req(req);
return -1;
}
/* reset completion flag */
io_complete_flag = 0;
ns_data_buffer_reset(ns, req, 0);
if (req->use_extended_lba)
rc = spdk_nvme_ns_cmd_read(ns, qpair, req->contig, req->lba, lba_count,
io_complete, req, io_flags);
else
rc = spdk_nvme_ns_cmd_read_with_md(ns, qpair, req->contig, req->metadata, req->lba, lba_count,
io_complete, req, io_flags, req->apptag_mask, req->apptag);
if (rc != 0) {
fprintf(stderr, "%s: %s read failed\n", dev->name, test_name);
spdk_nvme_ctrlr_free_io_qpair(qpair);
free_req(req);
return -1;
}
while (!io_complete_flag)
spdk_nvme_qpair_process_completions(qpair, 1);
if (io_complete_flag != 1) {
fprintf(stderr, "%s: %s read failed\n", dev->name, test_name);
spdk_nvme_ctrlr_free_io_qpair(qpair);
free_req(req);
return -1;
}
rc = ns_data_buffer_compare(ns, req, DATA_PATTERN);
if (rc < 0) {
fprintf(stderr, "%s: %s write/read success, but memcmp Failed\n", dev->name, test_name);
spdk_nvme_ctrlr_free_io_qpair(qpair);
free_req(req);
return -1;
}
fprintf(stdout, "%s: %s test passed\n", dev->name, test_name);
spdk_nvme_ctrlr_free_io_qpair(qpair);
free_req(req);
return rc;
}
/* Takes a request and forwards it to its destination server by opening a client
* connection. Returns the response of the destination server.
* This function frees memory allocated for the request also using free_req()
*/
void forward_request(int fd, req_t request){
int server;
size_t n, total_read;
cache_obj* entry;
char *name, *portstr, http[1024], buf[MAXLINE], cachebuf[MAX_OBJECT_SIZE];
rio_t rio;
cachebuf[0] = '\0';
name = strtok(request.domain, ":");
portstr = strtok(NULL, ":");
if(name == NULL){
free_req(request);
return;
}
if(portstr == NULL) portstr = "80";
// checking the cache is still updating it (age)
P(&w);
if((entry = in_cache(request.path, num_entries, cache)) != NULL){
V(&w);
Rio_writen(fd, entry->buf, entry->obj_size);
} else {
V(&w);
server = Open_clientfd_r(name, atoi(portstr));
if(server != -1){
sprintf(http, "GET /%s HTTP/1.0\r\n", request.path);
strcat(http, request.hdrs);
Rio_writen(server, http, strlen(http));
Rio_writen(server, "\r\n", 2);
} else {
reparse(&request);
char *wdpath;
wdpath = getcwd(NULL,0);
wdpath = Realloc(wdpath, strlen(wdpath) + strlen(request.path) +1);
strcat(wdpath, request.path);
server = open(wdpath, O_RDONLY);
Free(wdpath);
if(server == -1){
not_found(fd);
free_req(request);
return;
}
}
Rio_readinitb(&rio, server);
total_read = 0;
while((n = Rio_readlineb(&rio, buf, MAXLINE)) > 0){
if(total_read+n <= MAX_OBJECT_SIZE){
strcat(cachebuf, buf);
}
total_read += n;
Rio_writen(fd, buf, n);
}
// cache update, critical section
if(total_read <= MAX_OBJECT_SIZE){
P(&w);
cache = cache_write(request.path, cachebuf, num_entries, cache);
num_entries++;
V(&w);
}
}
free_req(request);
}
