| 1 |
/*------------------------------------------------------------------------- |
| 2 |
* |
| 3 |
* basebackup_target.c |
| 4 |
* Base backups can be "targeted", which means that they can be sent |
| 5 |
* somewhere other than to the client which requested the backup. |
| 6 |
* Furthermore, new targets can be defined by extensions. This file |
| 7 |
* contains code to support that functionality. |
| 8 |
* |
| 9 |
* Portions Copyright (c) 2010-2025, PostgreSQL Global Development Group |
| 10 |
* |
| 11 |
* IDENTIFICATION |
| 12 |
* src/backend/backup/basebackup_target.c |
| 13 |
* |
| 14 |
*------------------------------------------------------------------------- |
| 15 |
*/ |
| 16 |
#include "postgres.h" |
| 17 |
|
| 18 |
#include "backup/basebackup_target.h" |
| 19 |
#include "utils/memutils.h" |
| 20 |
|
| 21 |
typedef struct BaseBackupTargetType |
| 22 |
{ |
| 23 |
char *name; |
| 24 |
void *(*check_detail) (char *, char *); |
| 25 |
bbsink *(*get_sink) (bbsink *, void *); |
| 26 |
} BaseBackupTargetType; |
| 27 |
|
| 28 |
struct BaseBackupTargetHandle |
| 29 |
{ |
| 30 |
BaseBackupTargetType *type; |
| 31 |
void *detail_arg; |
| 32 |
}; |
| 33 |
|
| 34 |
static void initialize_target_list(void); |
| 35 |
static bbsink *blackhole_get_sink(bbsink *next_sink, void *detail_arg); |
| 36 |
static bbsink *server_get_sink(bbsink *next_sink, void *detail_arg); |
| 37 |
static void *reject_target_detail(char *target, char *target_detail); |
| 38 |
static void *server_check_detail(char *target, char *target_detail); |
| 39 |
|
| 40 |
static BaseBackupTargetType builtin_backup_targets[] = |
| 41 |
{ |
| 42 |
{ |
| 43 |
"blackhole", reject_target_detail, blackhole_get_sink |
| 44 |
}, |
| 45 |
{ |
| 46 |
"server", server_check_detail, server_get_sink |
| 47 |
}, |
| 48 |
{ |
| 49 |
NULL |
| 50 |
} |
| 51 |
}; |
| 52 |
|
| 53 |
static List *BaseBackupTargetTypeList = NIL; |
| 54 |
|
| 55 |
/* |
| 56 |
* Add a new base backup target type. |
| 57 |
* |
| 58 |
* This is intended for use by server extensions. |
| 59 |
*/ |
| 60 |
void |
| 61 |
BaseBackupAddTarget(char *name, |
| 62 |
void *(*check_detail) (char *, char *), |
| 63 |
bbsink *(*get_sink) (bbsink *, void *)) |
| 64 |
{ |
| 65 |
BaseBackupTargetType *newtype; |
| 66 |
MemoryContext oldcontext; |
| 67 |
ListCell *lc; |
| 68 |
|
| 69 |
/* If the target list is not yet initialized, do that first. */ |
| 70 |
if (BaseBackupTargetTypeList == NIL) |
| 71 |
initialize_target_list(); |
| 72 |
|
| 73 |
/* Search the target type list for an existing entry with this name. */ |
| 74 |
foreach(lc, BaseBackupTargetTypeList) |
| 75 |
{ |
| 76 |
BaseBackupTargetType *ttype = lfirst(lc); |
| 77 |
|
| 78 |
if (strcmp(ttype->name, name) == 0) |
| 79 |
{ |
| 80 |
/* |
| 81 |
* We found one, so update it. |
| 82 |
* |
| 83 |
* It is probably not a great idea to call BaseBackupAddTarget for |
| 84 |
* the same name multiple times, but if it happens, this seems |
| 85 |
* like the sanest behavior. |
| 86 |
*/ |
| 87 |
ttype->check_detail = check_detail; |
| 88 |
ttype->get_sink = get_sink; |
| 89 |
return; |
| 90 |
} |
| 91 |
} |
| 92 |
|
| 93 |
/* |
| 94 |
* We use TopMemoryContext for allocations here to make sure that the data |
| 95 |
* we need doesn't vanish under us; that's also why we copy the target |
| 96 |
* name into a newly-allocated chunk of memory. |
| 97 |
*/ |
| 98 |
oldcontext = MemoryContextSwitchTo(TopMemoryContext); |
| 99 |
newtype = palloc(sizeof(BaseBackupTargetType)); |
| 100 |
newtype->name = pstrdup(name); |
| 101 |
newtype->check_detail = check_detail; |
| 102 |
newtype->get_sink = get_sink; |
| 103 |
BaseBackupTargetTypeList = lappend(BaseBackupTargetTypeList, newtype); |
| 104 |
MemoryContextSwitchTo(oldcontext); |
| 105 |
} |
| 106 |
|
| 107 |
/* |
| 108 |
* Look up a base backup target and validate the target_detail. |
| 109 |
* |
| 110 |
* Extensions that define new backup targets will probably define a new |
| 111 |
* type of bbsink to match. Validation of the target_detail can be performed |
| 112 |
* either in the check_detail routine called here, or in the bbsink |
| 113 |
* constructor, which will be called from BaseBackupGetSink. It's mostly |
| 114 |
* a matter of taste, but the check_detail function runs somewhat earlier. |
| 115 |
*/ |
| 116 |
BaseBackupTargetHandle * |
| 117 |
BaseBackupGetTargetHandle(char *target, char *target_detail) |
| 118 |
{ |
| 119 |
ListCell *lc; |
| 120 |
|
| 121 |
/* If the target list is not yet initialized, do that first. */ |
| 122 |
if (BaseBackupTargetTypeList == NIL) |
| 123 |
initialize_target_list(); |
| 124 |
|
| 125 |
/* Search the target type list for a match. */ |
| 126 |
foreach(lc, BaseBackupTargetTypeList) |
| 127 |
{ |
| 128 |
BaseBackupTargetType *ttype = lfirst(lc); |
| 129 |
|
| 130 |
if (strcmp(ttype->name, target) == 0) |
| 131 |
{ |
| 132 |
BaseBackupTargetHandle *handle; |
| 133 |
|
| 134 |
/* Found the target. */ |
| 135 |
handle = palloc(sizeof(BaseBackupTargetHandle)); |
| 136 |
handle->type = ttype; |
| 137 |
handle->detail_arg = ttype->check_detail(target, target_detail); |
| 138 |
|
| 139 |
return handle; |
| 140 |
} |
| 141 |
} |
| 142 |
|
| 143 |
/* Did not find the target. */ |
| 144 |
ereport(ERROR, |
| 145 |
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED), |
| 146 |
errmsg("unrecognized target: \"%s\"", target))); |
| 147 |
|
| 148 |
/* keep compiler quiet */ |
| 149 |
return NULL; |
| 150 |
} |
| 151 |
|
| 152 |
/* |
| 153 |
* Construct a bbsink that will implement the backup target. |
| 154 |
* |
| 155 |
* The get_sink function does all the real work, so all we have to do here |
| 156 |
* is call it with the correct arguments. Whatever the check_detail function |
| 157 |
* returned is here passed through to the get_sink function. This lets those |
| 158 |
* two functions communicate with each other, if they wish. If not, the |
| 159 |
* check_detail function can simply return the target_detail and let the |
| 160 |
* get_sink function take it from there. |
| 161 |
*/ |
| 162 |
bbsink * |
| 163 |
BaseBackupGetSink(BaseBackupTargetHandle *handle, bbsink *next_sink) |
| 164 |
{ |
| 165 |
return handle->type->get_sink(next_sink, handle->detail_arg); |
| 166 |
} |
| 167 |
|
| 168 |
/* |
| 169 |
* Load predefined target types into BaseBackupTargetTypeList. |
| 170 |
*/ |
| 171 |
static void |
| 172 |
initialize_target_list(void) |
| 173 |
{ |
| 174 |
BaseBackupTargetType *ttype = builtin_backup_targets; |
| 175 |
MemoryContext oldcontext; |
| 176 |
|
| 177 |
oldcontext = MemoryContextSwitchTo(TopMemoryContext); |
| 178 |
while (ttype->name != NULL) |
| 179 |
{ |
| 180 |
BaseBackupTargetTypeList = lappend(BaseBackupTargetTypeList, ttype); |
| 181 |
++ttype; |
| 182 |
} |
| 183 |
MemoryContextSwitchTo(oldcontext); |
| 184 |
} |
| 185 |
|
| 186 |
/* |
| 187 |
* Normally, a get_sink function should construct and return a new bbsink that |
| 188 |
* implements the backup target, but the 'blackhole' target just throws the |
| 189 |
* data away. We could implement that by adding a bbsink that does nothing |
| 190 |
* but forward, but it's even cheaper to implement that by not adding a bbsink |
| 191 |
* at all. |
| 192 |
*/ |
| 193 |
static bbsink * |
| 194 |
blackhole_get_sink(bbsink *next_sink, void *detail_arg) |
| 195 |
{ |
| 196 |
return next_sink; |
| 197 |
} |
| 198 |
|
| 199 |
/* |
| 200 |
* Create a bbsink implementing a server-side backup. |
| 201 |
*/ |
| 202 |
static bbsink * |
| 203 |
server_get_sink(bbsink *next_sink, void *detail_arg) |
| 204 |
{ |
| 205 |
return bbsink_server_new(next_sink, detail_arg); |
| 206 |
} |
| 207 |
|
| 208 |
/* |
| 209 |
* Implement target-detail checking for a target that does not accept a |
| 210 |
* detail. |
| 211 |
*/ |
| 212 |
static void * |
| 213 |
reject_target_detail(char *target, char *target_detail) |
| 214 |
{ |
| 215 |
if (target_detail != NULL) |
| 216 |
ereport(ERROR, |
| 217 |
(errcode(ERRCODE_SYNTAX_ERROR), |
| 218 |
errmsg("target \"%s\" does not accept a target detail", |
| 219 |
target))); |
| 220 |
|
| 221 |
return NULL; |
| 222 |
} |
| 223 |
|
| 224 |
/* |
| 225 |
* Implement target-detail checking for a server-side backup. |
| 226 |
* |
| 227 |
* target_detail should be the name of the directory to which the backup |
| 228 |
* should be written, but we don't check that here. Rather, that check, |
| 229 |
* as well as the necessary permissions checking, happens in bbsink_server_new. |
| 230 |
*/ |
| 231 |
static void * |
| 232 |
server_check_detail(char *target, char *target_detail) |
| 233 |
{ |
| 234 |
if (target_detail == NULL) |
| 235 |
ereport(ERROR, |
| 236 |
(errcode(ERRCODE_SYNTAX_ERROR), |
| 237 |
errmsg("target \"%s\" requires a target detail", |
| 238 |
target))); |
| 239 |
|
| 240 |
return target_detail; |
| 241 |
} |