logo

oasis

Own branch of Oasis Linux (upstream: <https://git.sr.ht/~mcf/oasis/>) git clone https://anongit.hacktivis.me/git/oasis.git

0002-Use-a-compact-array-and-free-list-for-requests.patch (8027B)

    

  1. From 9e0a40fee13134d47980f01c68ec3b10e0d31bc3 Mon Sep 17 00:00:00 2001
  2. From: Michael Forney <mforney@mforney.org>
  3. Date: Sun, 5 Jun 2016 17:25:36 -0700
  4. Subject: [PATCH] Use a compact array and free list for requests
  6. ---
  7.  sshfs.c | 126 +++++++++++++++++++++++++++++++++++---------------------
  8.  1 file changed, 80 insertions(+), 46 deletions(-)
  10. diff --git a/sshfs.c b/sshfs.c
  11. index d4d624d..92b893e 100644
  12. --- a/sshfs.c
  13. +++ b/sshfs.c
  14. @@ -171,6 +171,17 @@ struct request {
  15.  	struct list_head list;
  16.  };
  17.  
  18. +union request_entry {
  19. +	struct request *req;
  20. +	uintptr_t next;
  21. +};
  22. +
  23. +struct request_table {
  24. +	union request_entry *entries;
  25. +	int len, cap;
  26. +	uint32_t free;
  27. +};
  28. +
  29.  struct sshfs_io {
  30.  	int num_reqs;
  31.  	pthread_cond_t finished;
  32. @@ -253,7 +264,7 @@ struct sshfs {
  33.  	int slave;
  34.  	char *host;
  35.  	char *base_path;
  36. -	GHashTable *reqtab;
  37. +	struct request_table reqtab;
  38.  	pthread_mutex_t lock;
  39.  	pthread_mutex_t lock_write;
  40.  	int processing_thread_started;
  41. @@ -1171,12 +1182,6 @@ static int do_write(struct iovec *iov, size_t count)
  42.  	return 0;
  43.  }
  44.  
  45. -static uint32_t sftp_get_id(void)
  46. -{
  47. -	static uint32_t idctr;
  48. -	return idctr++;
  49. -}
  50. -
  51.  static void buf_to_iov(const struct buffer *buf, struct iovec *iov)
  52.  {
  53.  	iov->iov_base = buf->p;
  54. @@ -1269,6 +1274,43 @@ static void request_free(struct request *req)
  55.  	g_free(req);
  56.  }
  57.  
  58. +static int request_table_insert(struct request_table *reqtab, struct request *req)
  59. +{
  60. +	union request_entry *entries;
  61. +	size_t cap;
  62. +
  63. +	if (reqtab->free) {
  64. +		req->id = reqtab->free;
  65. +		reqtab->free = reqtab->entries[req->id-1].next >> 1;
  66. +	} else {
  67. +		if (reqtab->len == reqtab->cap) {
  68. +			cap = reqtab->cap * 2 + 1;
  69. +			entries = realloc(reqtab->entries, cap * sizeof(reqtab->entries[0]));
  70. +			if (!entries)
  71. +				return -1;
  72. +			reqtab->cap = cap;
  73. +			reqtab->entries = entries;
  74. +		}
  75. +		req->id = ++reqtab->len;
  76. +	}
  77. +
  78. +	reqtab->entries[req->id-1].req = req;
  79. +	return 0;
  80. +}
  81. +
  82. +static struct request *request_table_lookup(struct request_table *reqtab, uint32_t id)
  83. +{
  84. +	if (reqtab->entries[id-1].next & 1)
  85. +		return NULL;
  86. +	return reqtab->entries[id-1].req;
  87. +}
  88. +
  89. +static void request_table_remove(struct request_table *reqtab, uint32_t id)
  90. +{
  91. +	reqtab->entries[id-1].next = (reqtab->free << 1) | 1;
  92. +	reqtab->free = id;
  93. +}
  94. +
  95.  static void chunk_free(struct read_chunk *chunk)
  96.  {
  97.  	while (!list_empty(&chunk->reqs)) {
  98. @@ -1298,22 +1340,6 @@ static void chunk_put_locked(struct read_chunk *chunk)
  99.  	pthread_mutex_unlock(&sshfs.lock);
  100.  }
  101.  
  102. -static int clean_req(void *key_, struct request *req, gpointer user_data_)
  103. -{
  104. -	(void) key_;
  105. -	(void) user_data_;
  106. -
  107. -	req->error = -EIO;
  108. -	if (req->want_reply)
  109. -		sem_post(&req->ready);
  110. -	else {
  111. -		if (req->end_func)
  112. -			req->end_func(req);
  113. -		request_free(req);
  114. -	}
  115. -	return TRUE;
  116. -}
  117. -
  118.  static int process_one_request(void)
  119.  {
  120.  	int res;
  121. @@ -1330,8 +1356,7 @@ static int process_one_request(void)
  122.  		return -1;
  123.  
  124.  	pthread_mutex_lock(&sshfs.lock);
  125. -	req = (struct request *)
  126. -		g_hash_table_lookup(sshfs.reqtab, GUINT_TO_POINTER(id));
  127. +	req = request_table_lookup(&sshfs.reqtab, id);
  128.  	if (req == NULL)
  129.  		fprintf(stderr, "request %i not found\n", id);
  130.  	else {
  131. @@ -1343,7 +1368,7 @@ static int process_one_request(void)
  132.  		    sshfs.outstanding_len <= sshfs.max_outstanding_len) {
  133.  			pthread_cond_broadcast(&sshfs.outstanding_cond);
  134.  		}
  135. -		g_hash_table_remove(sshfs.reqtab, GUINT_TO_POINTER(id));
  136. +		request_table_remove(&sshfs.reqtab, id);
  137.  	}
  138.  	pthread_mutex_unlock(&sshfs.lock);
  139.  	if (req != NULL) {
  140. @@ -1404,6 +1429,9 @@ static void close_conn(void)
  141.  
  142.  static void *process_requests(void *data_)
  143.  {
  144. +	int i;
  145. +	struct request *req;
  146. +
  147.  	(void) data_;
  148.  
  149.  	while (1) {
  150. @@ -1414,7 +1442,20 @@ static void *process_requests(void *data_)
  151.  	pthread_mutex_lock(&sshfs.lock);
  152.  	sshfs.processing_thread_started = 0;
  153.  	close_conn();
  154. -	g_hash_table_foreach_remove(sshfs.reqtab, (GHRFunc) clean_req, NULL);
  155. +	for (i = 0; i < sshfs.reqtab.len; ++i) {
  156. +		if (sshfs.reqtab.entries[i].next & 1)
  157. +			continue;
  158. +		req = sshfs.reqtab.entries[i].req;
  159. +		req->error = -EIO;
  160. +		if (req->want_reply)
  161. +			sem_post(&req->ready);
  162. +		else {
  163. +			if (req->end_func)
  164. +				req->end_func(req);
  165. +			request_free(req);
  166. +		}
  167. +		request_table_remove(&sshfs.reqtab, i + 1);
  168. +	}
  169.  	sshfs.connver ++;
  170.  	sshfs.outstanding_len = 0;
  171.  	pthread_cond_broadcast(&sshfs.outstanding_cond);
  172. @@ -1562,7 +1603,6 @@ static int sftp_error_to_errno(uint32_t error)
  173.  static void sftp_detect_uid()
  174.  {
  175.  	int flags;
  176. -	uint32_t id = sftp_get_id();
  177.  	uint32_t replid;
  178.  	uint8_t type;
  179.  	struct buffer buf;
  180. @@ -1572,7 +1612,7 @@ static void sftp_detect_uid()
  181.  	buf_init(&buf, 5);
  182.  	buf_add_string(&buf, ".");
  183.  	buf_to_iov(&buf, &iov[0]);
  184. -	if (sftp_send_iov(SSH_FXP_STAT, id, iov, 1) == -1)
  185. +	if (sftp_send_iov(SSH_FXP_STAT, 0, iov, 1) == -1)
  186.  		goto out;
  187.  	buf_clear(&buf);
  188.  	if (sftp_read(&type, &buf) == -1)
  189. @@ -1583,7 +1623,7 @@ static void sftp_detect_uid()
  190.  	}
  191.  	if (buf_get_uint32(&buf, &replid) == -1)
  192.  		goto out;
  193. -	if (replid != id) {
  194. +	if (replid != 0) {
  195.  		fprintf(stderr, "bad reply ID\n");
  196.  		goto out;
  197.  	}
  198. @@ -1618,7 +1658,6 @@ out:
  199.  static int sftp_check_root(const char *base_path)
  200.  {
  201.  	int flags;
  202. -	uint32_t id = sftp_get_id();
  203.  	uint32_t replid;
  204.  	uint8_t type;
  205.  	struct buffer buf;
  206. @@ -1630,7 +1669,7 @@ static int sftp_check_root(const char *base_path)
  207.  	buf_init(&buf, 0);
  208.  	buf_add_string(&buf, remote_dir);
  209.  	buf_to_iov(&buf, &iov[0]);
  210. -	if (sftp_send_iov(SSH_FXP_LSTAT, id, iov, 1) == -1)
  211. +	if (sftp_send_iov(SSH_FXP_LSTAT, 0, iov, 1) == -1)
  212.  		goto out;
  213.  	buf_clear(&buf);
  214.  	if (sftp_read(&type, &buf) == -1)
  215. @@ -1641,7 +1680,7 @@ static int sftp_check_root(const char *base_path)
  216.  	}
  217.  	if (buf_get_uint32(&buf, &replid) == -1)
  218.  		goto out;
  219. -	if (replid != id) {
  220. +	if (replid != 0) {
  221.  		fprintf(stderr, "bad reply ID\n");
  222.  		goto out;
  223.  	}
  224. @@ -1831,7 +1870,6 @@ static int sftp_request_send(uint8_t type, struct iovec *iov, size_t count,
  225.                               struct request **reqp)
  226.  {
  227.  	int err;
  228. -	uint32_t id;
  229.  	struct request *req = g_new0(struct request, 1);
  230.  
  231.  	req->want_reply = want_reply;
  232. @@ -1842,8 +1880,6 @@ static int sftp_request_send(uint8_t type, struct iovec *iov, size_t count,
  233.  	pthread_mutex_lock(&sshfs.lock);
  234.  	if (begin_func)
  235.  		begin_func(req);
  236. -	id = sftp_get_id();
  237. -	req->id = id;
  238.  	err = start_processing_thread();
  239.  	if (err) {
  240.  		pthread_mutex_unlock(&sshfs.lock);
  241. @@ -1854,21 +1890,24 @@ static int sftp_request_send(uint8_t type, struct iovec *iov, size_t count,
  242.  	while (sshfs.outstanding_len > sshfs.max_outstanding_len)
  243.  		pthread_cond_wait(&sshfs.outstanding_cond, &sshfs.lock);
  244.  
  245. -	g_hash_table_insert(sshfs.reqtab, GUINT_TO_POINTER(id), req);
  246. +	if (request_table_insert(&sshfs.reqtab, req) < 0)
  247. +		abort();
  248.  	if (sshfs.debug) {
  249.  		gettimeofday(&req->start, NULL);
  250.  		sshfs.num_sent++;
  251.  		sshfs.bytes_sent += req->len;
  252.  	}
  253. -	DEBUG("[%05i] %s\n", id, type_name(type));
  254. +	DEBUG("[%05i] %s\n", req->id, type_name(type));
  255.  	pthread_mutex_unlock(&sshfs.lock);
  256.  
  257.  	err = -EIO;
  258. -	if (sftp_send_iov(type, id, iov, count) == -1) {
  259. +	if (sftp_send_iov(type, req->id, iov, count) == -1) {
  260.  		gboolean rmed;
  261.  
  262.  		pthread_mutex_lock(&sshfs.lock);
  263. -		rmed = g_hash_table_remove(sshfs.reqtab, GUINT_TO_POINTER(id));
  264. +		rmed = !!request_table_lookup(&sshfs.reqtab, req->id);
  265. +		if (rmed)
  266. +			request_table_remove(&sshfs.reqtab, req->id);
  267.  		pthread_mutex_unlock(&sshfs.lock);
  268.  
  269.  		if (!rmed && !want_reply) {
  270. @@ -2041,7 +2080,7 @@ static int sftp_readdir_send(struct request **req, struct buffer *handle)
  271.  
  272.  static int sshfs_req_pending(struct request *req)
  273.  {
  274. -	if (g_hash_table_lookup(sshfs.reqtab, GUINT_TO_POINTER(req->id)))
  275. +	if (request_table_lookup(&sshfs.reqtab, req->id))
  276.  		return 1;
  277.  	else
  278.  		return 0;
  279. @@ -3312,11 +3351,6 @@ static int processing_init(void)
  280.  	pthread_mutex_init(&sshfs.lock, NULL);
  281.  	pthread_mutex_init(&sshfs.lock_write, NULL);
  282.  	pthread_cond_init(&sshfs.outstanding_cond, NULL);
  283. -	sshfs.reqtab = g_hash_table_new(NULL, NULL);
  284. -	if (!sshfs.reqtab) {
  285. -		fprintf(stderr, "failed to create hash table\n");
  286. -		return -1;
  287. -	}
  288.  	return 0;
  289.  }
  290.  
  291. -- 
  292. 2.24.0