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
| | /*
* Copyright (C) 2012-2013, Eric Wong <normalperson@yhbt.net>
* License: GPLv3 or later (see COPYING for details)
*/
#define _GNU_SOURCE 1 /* needed for _ATFILE_SOURCE on glibc 2.5 - 2.9 */
#include <dirent.h> /* needed for FreeBSD */
#include "cmogstored.h"
/* same default as MogileFS upstream */
static pthread_mutex_t svc_lock = PTHREAD_MUTEX_INITIALIZER;
static Hash_table *by_docroot; /* enforce one mog_svc per docroot: */
static mode_t mog_umask;
static void svc_free(void *ptr)
{
struct mog_svc *svc = ptr;
if (closedir(svc->dir) < 0)
syslog(LOG_ERR, "closedir(%s) failed with: %m", svc->docroot);
CHECK(int, 0, pthread_mutex_destroy(&svc->devstats_lock));
mog_free(svc->docroot);
if (svc->by_st_dev)
hash_free(svc->by_st_dev);
if (svc->by_mog_devid)
hash_free(svc->by_mog_devid);
free(svc);
}
static size_t svc_hash(const void *x, size_t tablesize)
{
const struct mog_svc *svc = x;
return hash_string(svc->docroot, tablesize);
}
static bool svc_cmp(const void *a, const void *b)
{
const struct mog_svc *svc_a = a;
const struct mog_svc *svc_b = b;
return strcmp(svc_a->docroot, svc_b->docroot) == 0;
}
static void svc_atexit(void) /* called atexit */
{
hash_free(by_docroot);
}
static void svc_once(void)
{
by_docroot = hash_initialize(7, NULL, svc_hash, svc_cmp, svc_free);
mog_oom_if_null(by_docroot);
mog_umask = umask(0);
umask(mog_umask);
atexit(svc_atexit);
}
struct mog_svc * mog_svc_new(const char *docroot)
{
struct mog_svc *svc;
DIR *dir;
int fd;
if (!docroot) docroot = MOG_DEFAULT_DOCROOT;
docroot = mog_canonpath_die(docroot, CAN_EXISTING);
dir = opendir(docroot);
if (dir == NULL) {
syslog(LOG_ERR, "opendir(%s) failed with: %m", docroot);
mog_free(docroot);
return NULL;
}
fd = dirfd(dir);
if (fd < 0) {
syslog(LOG_ERR, "dirfd(%s) failed with: %m", docroot);
mog_free(docroot);
return NULL;
}
CHECK(int, 0, pthread_mutex_lock(&svc_lock));
if (!by_docroot)
svc_once();
svc = xzalloc(sizeof(struct mog_svc));
svc->docroot = docroot;
svc->docroot_fd = fd;
svc->dir = dir;
svc->put_perms = (~mog_umask) & 0666;
svc->mkcol_perms = (~mog_umask) & 0777;
svc->idle_timeout = 5;
CHECK(int, 0, pthread_mutex_init(&svc->devstats_lock, NULL));
CHECK(int, 0, pthread_mutex_init(&svc->by_mog_devid_lock, NULL));
svc->by_mog_devid = hash_initialize(7, NULL, mog_dev_hash,
mog_dev_cmp, mog_dev_free);
mog_oom_if_null(svc->by_mog_devid);
switch (hash_insert_if_absent(by_docroot, svc, NULL)) {
case 0:
svc_free(svc);
svc = NULL;
case 1: break;
default: mog_oom();
}
CHECK(int, 0, pthread_mutex_unlock(&svc_lock));
return svc;
}
size_t mog_svc_each(Hash_processor processor, void *data)
{
size_t rv;
CHECK(int, 0, pthread_mutex_lock(&svc_lock));
rv = hash_do_for_each(by_docroot, processor, data);
CHECK(int, 0, pthread_mutex_unlock(&svc_lock));
return rv;
}
static bool cloexec_disable(struct mog_fd *mfd)
{
if (mfd)
CHECK(int, 0, mog_set_cloexec(mfd->fd, false));
return true;
}
static bool svc_cloexec_off_i(void *svcptr, void *unused)
{
struct mog_svc *svc = svcptr;
return (cloexec_disable(svc->mgmt_mfd)
&& cloexec_disable(svc->http_mfd)
&& cloexec_disable(svc->httpget_mfd));
}
/*
* Only call this from a freshly forked upgrade child process.
* This holds no locks to avoid potential deadlocks in post-fork mutexes
*/
void mog_svc_upgrade_prepare(void)
{
(void)hash_do_for_each(by_docroot, svc_cloexec_off_i, NULL);
}
|