|
/**
|
|
* Copyright © 2019, Oracle and/or its affiliates. All rights reserved.
|
|
*
|
|
* Licensed under the Universal Permissive License v 1.0 as shown at
|
|
* http://oss.oracle.com/licenses/upl
|
|
*
|
|
*/
|
|
#include <assert.h>
|
|
#include <sys/stat.h>
|
|
#include <pthread.h>
|
|
#include <dirent.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include "putils.h"
|
|
#include "malloc.h"
|
|
/* parallel diff of a directory heirarchy that also checks ownership and attributes */
|
|
|
|
struct diff_task {
|
|
char *relative_path;
|
|
struct diff_task *next;
|
|
};
|
|
|
|
// Worker state
|
|
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; ;
|
|
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
|
|
struct diff_task *tasks = NULL;
|
|
enum { n_workers = 32};
|
|
size_t n_working = 0; // When tasks==NULL and n_working==0, we are done
|
|
pthread_t workers[n_workers];
|
|
|
|
#define PMAX 4096
|
|
const char *src_dir;
|
|
const char *dst_dir;
|
|
|
|
int check_ownership = 1;
|
|
|
|
// From the qsort man page:
|
|
static int cmpstringp(const void *p1, const void *p2) {
|
|
// The actual arguments to this function are "pointers to pointers
|
|
// to char", but strcmp(3) arguments are "pointers to char", hence
|
|
// the following cast plus dereference.
|
|
return strcmp(* (char * const *) p1, * (char * const *) p2);
|
|
}
|
|
|
|
static void collect_and_sort_pathnames(const char *abs_path,
|
|
// output:
|
|
size_t *np,
|
|
char ***paths_p)
|
|
// Collect all the pathnames in a directory, except for . and .., and
|
|
// return them in sorted order.
|
|
{
|
|
size_t n = 0;
|
|
size_t limit = 2;
|
|
char **MALLOC_N(paths, limit);
|
|
DIR *dir = opendir(abs_path);
|
|
assert(dir);
|
|
struct dirent *dentry;
|
|
while ((dentry = readdir(dir))) {
|
|
if (strcmp(dentry->d_name, ".") == 0) continue;
|
|
if (strcmp(dentry->d_name, "..") == 0) continue;
|
|
if (n >= limit) {
|
|
limit *= 2;
|
|
REALLOC(paths, limit);
|
|
}
|
|
assert(n < limit);
|
|
paths[n++] = strdup(dentry->d_name);
|
|
}
|
|
closedir(dir);
|
|
qsort(paths, n, sizeof(char*), cmpstringp);
|
|
*np = n;
|
|
*paths_p = paths;
|
|
}
|
|
|
|
static void diff_r(const char *relative_path) {
|
|
char src_path[PMAX];
|
|
{
|
|
int n = snprintf(src_path, PMAX, "%s/%s", src_dir, relative_path);
|
|
assert(n < PMAX);
|
|
}
|
|
char dst_path[PMAX];
|
|
{
|
|
int n = snprintf(dst_path, PMAX, "%s/%s", dst_dir, relative_path);
|
|
assert(n < PMAX);
|
|
}
|
|
struct stat src_stat, dst_stat;
|
|
{
|
|
int src_r = lstat(src_path, &src_stat);
|
|
assert (src_r == 0);
|
|
}
|
|
{
|
|
int dst_r = lstat(dst_path, &dst_stat);
|
|
assert(dst_r == 0);
|
|
}
|
|
assert((src_stat.st_mode & S_IFMT) == (dst_stat.st_mode & S_IFMT));
|
|
{
|
|
mode_t mask = 0777;
|
|
if ((src_stat.st_mode & mask) != (dst_stat.st_mode & mask)) {
|
|
fprintf(stderr, "masks differ %s and %s\n", src_path, dst_path);
|
|
assert(0);
|
|
}
|
|
}
|
|
if (check_ownership) {
|
|
if (src_stat.st_uid != dst_stat.st_uid) {
|
|
fprintf(stderr, "uid doesn't match for %s and %s\n", src_path, dst_path);
|
|
}
|
|
assert(src_stat.st_uid == dst_stat.st_uid);
|
|
assert(src_stat.st_gid == dst_stat.st_gid);
|
|
}
|
|
if (S_ISREG(dst_stat.st_mode)) {
|
|
assert(src_stat.st_size == dst_stat.st_size);
|
|
FILE *src_f = fopen(src_path, "r");
|
|
FILE *dst_f = fopen(dst_path, "r");
|
|
if (src_f == NULL || dst_f == NULL) {
|
|
fprintf(stderr, "Failed to open one or more files\n");
|
|
return;
|
|
}
|
|
for (size_t i = 0 ; i < (size_t)(src_stat.st_size); i++) {
|
|
int src_c = getc(src_f); assert(src_c != EOF);
|
|
int dst_c = getc(dst_f); assert(dst_c != EOF);
|
|
assert(src_c == dst_c);
|
|
}
|
|
fclose(src_f);
|
|
fclose(dst_f);
|
|
} else if (S_ISDIR(src_stat.st_mode)) {
|
|
size_t sn, dn;
|
|
char **sps, **dps;
|
|
collect_and_sort_pathnames(src_path, &sn, &sps);
|
|
collect_and_sort_pathnames(dst_path, &dn, &dps);
|
|
assert(sn == dn);
|
|
for (size_t i = 0; i < sn; i++) {
|
|
assert(strcmp(sps[i], dps[i]) == 0);
|
|
struct diff_task *MALLOC(task);
|
|
char sub_rel_path[PMAX];
|
|
{
|
|
int n = snprintf(sub_rel_path, PMAX, "%s/%s", relative_path, sps[i]);
|
|
assert(n < PMAX);
|
|
}
|
|
char *srp = strdup(sub_rel_path);
|
|
pthread_mutex_lock(&mutex);
|
|
*task = (struct diff_task){.relative_path = srp,
|
|
.next = tasks};
|
|
tasks = task;
|
|
pthread_cond_signal(&cond);
|
|
pthread_mutex_unlock(&mutex);
|
|
}
|
|
} else if (S_ISLNK(src_stat.st_mode)) {
|
|
char slname[PMAX];
|
|
ssize_t slen = readlink(src_path, slname, PMAX);
|
|
assert(slen >= 0 && slen < PMAX);
|
|
char dlname[PMAX];
|
|
ssize_t dlen = readlink(dst_path, dlname, PMAX);
|
|
assert(dlen >= 0 && dlen < PMAX);
|
|
assert(slen == dlen);
|
|
slname[slen] = 0;
|
|
dlname[dlen] = 0;
|
|
if (0 != strcmp(slname, dlname)) {
|
|
fprintf(stderr, "%s -> %s is not the same as %s -> %s\n", src_path, slname, dst_path, dlname);
|
|
assert(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void* run_worker(void *d) {
|
|
pthread_mutex_lock(&mutex);
|
|
while (1) {
|
|
// Lock is held here.
|
|
while (!tasks && n_working) {
|
|
pthread_cond_wait(&cond, &mutex);
|
|
}
|
|
// Either there is a task or n_working==0
|
|
if (tasks) {
|
|
struct diff_task *task = tasks;
|
|
tasks = task->next;
|
|
n_working++;
|
|
pthread_mutex_unlock(&mutex);
|
|
diff_r(task->relative_path);
|
|
free(task->relative_path);
|
|
free(task);
|
|
pthread_mutex_lock(&mutex);
|
|
n_working--;
|
|
if (tasks == NULL && n_working == 0) {
|
|
pthread_cond_broadcast(&cond);
|
|
}
|
|
} else if (n_working == 0) {
|
|
// No tasks and nothing to do.
|
|
pthread_mutex_unlock(&mutex);
|
|
return d;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void run_workers(void) {
|
|
MALLOC(tasks);
|
|
*tasks = (struct diff_task){.relative_path = strdup(""),
|
|
.next = NULL};
|
|
n_working = 0;
|
|
for (size_t i = 0; i < n_workers; i++) {
|
|
pthread_create(&workers[i], NULL, run_worker, &workers[i]);
|
|
}
|
|
for (size_t i = 0; i < n_workers; i++) {
|
|
void *result;
|
|
pthread_join(workers[i], &result);
|
|
}
|
|
}
|
|
|
|
int main (int argc, const char *argv[]) {
|
|
assert(argc == 3);
|
|
src_dir = argv[1];
|
|
dst_dir = argv[2];
|
|
run_workers();
|
|
return 0;
|
|
}
|