-
Notifications
You must be signed in to change notification settings - Fork 0
/
dent.c
216 lines (179 loc) · 5.86 KB
/
dent.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <limits.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include "dent.h" // Assuming this header defines struct linux_dirent64
#include <dirent.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stddef.h>
// Buffer size for getdents64
#define BUF_SIZE 4096
// Increase buffer sizes
#define READ_BUF_SIZE (256 * 1024) // 256 KB buffer for reading directory entries
#define WRITE_BUF_SIZE (256 * 1024) // 256 KB buffer for output
struct linux_dirent64 {
ino64_t d_ino;
off64_t d_off;
unsigned short d_reclen;
unsigned char d_type;
char d_name[];
};
// Initialize the work queue
void queue_init(work_queue_t *queue) {
queue->head = NULL;
queue->tail = NULL;
pthread_mutex_init(&queue->mutex, NULL);
pthread_cond_init(&queue->cond, NULL);
queue->tasks_in_progress = 0;
}
// Push a new path into the queue
void queue_push(work_queue_t *queue, char *path) {
work_node_t *node = malloc(sizeof(work_node_t));
if (!node) {
perror("malloc");
exit(EXIT_FAILURE);
}
node->path = path;
node->next = NULL;
pthread_mutex_lock(&queue->mutex);
if (queue->tail) {
queue->tail->next = node;
} else {
queue->head = node;
}
queue->tail = node;
queue->tasks_in_progress++;
pthread_cond_signal(&queue->cond);
pthread_mutex_unlock(&queue->mutex);
}
// Pop a path from the queue
char *queue_pop(work_queue_t *queue) {
pthread_mutex_lock(&queue->mutex);
while (!queue->head && queue->tasks_in_progress > 0) {
pthread_cond_wait(&queue->cond, &queue->mutex);
}
if (!queue->head && queue->tasks_in_progress == 0) {
pthread_mutex_unlock(&queue->mutex);
return NULL; // No more work to do
}
work_node_t *node = queue->head;
queue->head = node->next;
if (!queue->head) {
queue->tail = NULL;
}
pthread_mutex_unlock(&queue->mutex);
char *path = node->path;
free(node);
return path;
}
// Decrement the tasks_in_progress counter
void task_done(work_queue_t *queue) {
pthread_mutex_lock(&queue->mutex);
queue->tasks_in_progress--;
if (queue->tasks_in_progress == 0) {
// No more tasks; wake up all threads
pthread_cond_broadcast(&queue->cond);
}
pthread_mutex_unlock(&queue->mutex);
}
// Destroy the work queue
void queue_destroy(work_queue_t *queue) {
pthread_mutex_destroy(&queue->mutex);
pthread_cond_destroy(&queue->cond);
}
// Function to list the contents of a directory using getdents64
void list_directory(const char *path, work_queue_t *queue) {
// Thread-local buffers to avoid malloc/free and improve cache locality
static __thread char read_buf[READ_BUF_SIZE];
static __thread char write_buf[WRITE_BUF_SIZE];
static __thread size_t write_buf_pos = 0;
static __thread char new_path[PATH_MAX];
int fd = open(path, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC);
if (fd == -1) {
perror("open");
return;
}
ssize_t nread;
while ((nread = syscall(SYS_getdents64, fd, read_buf, READ_BUF_SIZE)) > 0) {
char *ptr = read_buf;
char *end = read_buf + nread;
while (ptr < end) {
struct linux_dirent64 *d = (struct linux_dirent64 *)ptr;
ptr += d->d_reclen;
// Prefetch next entry to improve cache performance
__builtin_prefetch(ptr, 0, 1);
// Skip "." and ".."
if (d->d_name[0] == '.') {
if (d->d_name[1] == '\0' ||
(d->d_name[1] == '.' && d->d_name[2] == '\0')) {
continue;
}
}
// Calculate lengths without strlen
size_t path_len = strlen(path);
size_t name_len = d->d_reclen - offsetof(struct linux_dirent64, d_name) - 1;
// Ensure name is null-terminated
d->d_name[name_len] = '\0';
// Check for path length overflow
if (path_len + 1 + name_len >= PATH_MAX) {
// Path too long; skip this entry
continue;
}
// Construct new_path using thread-local buffer
memcpy(new_path, path, path_len);
new_path[path_len] = '/';
memcpy(new_path + path_len + 1, d->d_name, name_len + 1); // Copy null terminator
// Accumulate output in write buffer
size_t new_path_len = path_len + 1 + name_len;
if (write_buf_pos + new_path_len + 1 > WRITE_BUF_SIZE) {
// Flush the buffer
fwrite(write_buf, 1, write_buf_pos, stdout);
write_buf_pos = 0;
}
memcpy(write_buf + write_buf_pos, new_path, new_path_len);
write_buf_pos += new_path_len;
write_buf[write_buf_pos++] = '\n';
if (d->d_type == DT_DIR) {
// It's a directory; push it onto the queue
char *path_copy = strdup(new_path);
if (!path_copy) {
perror("strdup");
continue;
}
queue_push(queue, path_copy);
}
// Skip entries with unknown type to avoid stat
}
}
if (nread == -1) {
perror("getdents64");
}
// Flush any remaining output
if (write_buf_pos > 0) {
fwrite(write_buf, 1, write_buf_pos, stdout);
write_buf_pos = 0;
}
close(fd);
}
// Worker thread function
void *worker_function(void *arg) {
work_queue_t *queue = (work_queue_t *)arg;
while (1) {
char *path = queue_pop(queue);
if (path == NULL) {
break; // No more work to do
}
list_directory(path, queue);
free(path);
task_done(queue);
}
return NULL;
}