Print this page
NEX-9532 NDMP: readdir errors when file/directory has special characters
Reviewed by: Peer Dampmann <peer.dampmann@nexenta.com>
Reviewed by: Alexander Eremin <alexander.eremin@nexenta.com>
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
NEX-2911 NDMP logging should use syslog and is too chatty
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/ndmpd/ndmp/ndmpd_door.c
+++ new/usr/src/cmd/ndmpd/ndmp/ndmpd_door.c
1 1 /*
2 2 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
3 3 * Use is subject to license terms.
4 4 */
5 5
6 6 /*
7 7 * BSD 3 Clause License
8 8 *
9 9 * Copyright (c) 2007, The Storage Networking Industry Association.
10 10 *
11 11 * Redistribution and use in source and binary forms, with or without
12 12 * modification, are permitted provided that the following conditions
13 13 * are met:
14 14 * - Redistributions of source code must retain the above copyright
15 15 * notice, this list of conditions and the following disclaimer.
16 16 *
17 17 * - Redistributions in binary form must reproduce the above copyright
18 18 * notice, this list of conditions and the following disclaimer in
19 19 * the documentation and/or other materials provided with the
20 20 * distribution.
21 21 *
22 22 * - Neither the name of The Storage Networking Industry Association (SNIA)
23 23 * nor the names of its contributors may be used to endorse or promote
24 24 * products derived from this software without specific prior written
25 25 * permission.
26 26 *
27 27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28 28 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
↓ open down ↓ |
28 lines elided |
↑ open up ↑ |
29 29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 30 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31 31 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 37 * POSSIBILITY OF SUCH DAMAGE.
38 38 */
39 +/* Copyright 2017 Nexenta Systems, Inc. All rights reserved. */
39 40
40 41 /* This file contains all the door server code */
41 42
43 +#include <syslog.h>
42 44 #include <door.h>
43 45 #include <alloca.h>
44 46 #include <errno.h>
45 47 #include <note.h>
46 48 #include <libintl.h>
47 49 #include <ndmpd_door.h>
48 50 #include "ndmpd.h"
49 51
50 52 /* static variables */
51 53 static int ndmp_door_fildes = -1;
52 54 static mutex_t ndmp_doorsrv_mutex;
53 55
54 56 /* static routines */
55 57 static void ndmp_door_server(void *cookie, char *ptr, size_t size,
56 58 door_desc_t *dp, uint_t n_desc);
57 59
58 60 /*
59 61 * Statistics used in ndmpstat command
60 62 */
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
61 63 ndmp_stat_t ndstat;
62 64
63 65 int
64 66 ndmp_door_init(void)
65 67 {
66 68 int fd;
67 69
68 70 (void) mutex_lock(&ndmp_doorsrv_mutex);
69 71
70 72 if (ndmp_door_fildes != -1) {
71 - NDMP_LOG(LOG_DEBUG,
73 + syslog(LOG_ERR,
72 74 "ndmp_door_init: ndmpd service is already running.");
73 75 (void) mutex_unlock(&ndmp_doorsrv_mutex);
74 76 return (0);
75 77 }
76 78
77 79 if ((ndmp_door_fildes = door_create(ndmp_door_server,
78 80 NULL, DOOR_UNREF)) < 0) {
79 - NDMP_LOG(LOG_DEBUG, "ndmp_door_init: Could not create door.");
81 + syslog(LOG_ERR, "ndmp_door_init: Could not create door.");
80 82 (void) mutex_unlock(&ndmp_doorsrv_mutex);
81 83 return (-1);
82 84 }
83 85
84 86 (void) unlink(NDMP_DOOR_SVC);
85 87
86 88 if ((fd = creat(NDMP_DOOR_SVC, 0444)) < 0) {
87 - NDMP_LOG(LOG_DEBUG, "ndmp_door_init: Can't create %s: %m.",
89 + syslog(LOG_ERR, "ndmp_door_init: Can't create %s: %m.",
88 90 NDMP_DOOR_SVC);
89 91 (void) door_revoke(ndmp_door_fildes);
90 92 ndmp_door_fildes = -1;
91 93 (void) mutex_unlock(&ndmp_doorsrv_mutex);
92 94 return (-1);
93 95 }
94 96
95 97 (void) close(fd);
96 98 (void) fdetach(NDMP_DOOR_SVC);
97 99
98 100 if (fattach(ndmp_door_fildes, NDMP_DOOR_SVC) < 0) {
99 - NDMP_LOG(LOG_DEBUG, "ndmp_door_init: fattach failed %m");
101 + syslog(LOG_ERR, "ndmp_door_init: fattach failed %m");
100 102 (void) door_revoke(ndmp_door_fildes);
101 103 ndmp_door_fildes = -1;
102 104 (void) mutex_unlock(&ndmp_doorsrv_mutex);
103 105 return (-1);
104 106 }
105 107
106 - NDMP_LOG(LOG_DEBUG, "ndmp_door_init: Door server successfully started");
108 + syslog(LOG_DEBUG, "ndmp_door_init: Door server successfully started");
107 109 (void) mutex_unlock(&ndmp_doorsrv_mutex);
108 110 return (0);
109 111 }
110 112
111 113 void
112 114 ndmp_door_fini(void)
113 115 {
114 116 (void) mutex_lock(&ndmp_doorsrv_mutex);
115 117
116 118 if (ndmp_door_fildes != -1) {
117 119 (void) fdetach(NDMP_DOOR_SVC);
118 120 (void) door_revoke(ndmp_door_fildes);
119 121 ndmp_door_fildes = -1;
120 122 }
121 123
122 124 (void) mutex_unlock(&ndmp_doorsrv_mutex);
123 125 }
124 126
125 127 boolean_t
126 128 ndmp_door_check(void)
127 129 {
128 130 door_info_t info;
129 131 int door;
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
130 132
131 133 if ((door = open(NDMP_DOOR_SVC, O_RDONLY)) < 0)
132 134 return (0);
133 135
134 136 if (door_info(door, &info) < 0) {
135 137 (void) close(door);
136 138 return (0);
137 139 }
138 140
139 141 if (info.di_target > 0) {
140 - NDMP_LOG(LOG_ERR,
142 + syslog(LOG_ERR,
141 143 "Service already running: pid %ld", info.di_target);
142 144 (void) close(door);
143 145 return (1);
144 146 }
145 147
146 148 (void) close(door);
147 149 return (0);
148 150 }
149 151
150 152 /* door server */
151 153 /*ARGSUSED*/
152 154 void
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
153 155 ndmp_door_server(void *cookie, char *ptr, size_t size,
154 156 door_desc_t *dp, uint_t n_desc)
155 157 {
156 158 NOTE(ARGUNUSED(cookie,dp,n_desc))
157 159 int req_type;
158 160 char *buf;
159 161 int buflen;
160 162 unsigned int used;
161 163 ndmp_door_ctx_t *dec_ctx;
162 164 ndmp_door_ctx_t *enc_ctx;
163 - unsigned int dec_status;
164 - unsigned int enc_status;
165 + unsigned int dec_status = EINVAL;
166 + unsigned int enc_status = EINVAL;
165 167
166 168 dec_ctx = ndmp_door_decode_start(ptr, size);
167 169 if (dec_ctx == 0)
168 170 return;
169 171
170 172 req_type = ndmp_door_get_uint32(dec_ctx);
171 173 buflen = NDMP_DOOR_SIZE;
172 174
173 175 if ((buf = alloca(buflen)) == NULL) {
174 - NDMP_LOG(LOG_DEBUG, "Out of memory.");
176 + syslog(LOG_ERR, "Out of memory.");
175 177 (void) ndmp_door_decode_finish(dec_ctx);
176 178 return;
177 179 }
178 180
179 181 enc_ctx = ndmp_door_encode_start(buf, buflen);
180 182 if (enc_ctx == 0) {
181 183 (void) ndmp_door_decode_finish(dec_ctx);
182 184 return;
183 185 }
184 186
185 187 if (req_type != NDMP_GET_STAT)
186 - NDMP_LOG(LOG_DEBUG, "ndmp_door_server: req_type=%d", req_type);
188 + syslog(LOG_DEBUG, "ndmp_door_server: req_type=%d", req_type);
187 189
188 190 switch (req_type) {
189 191 case NDMP_GET_DOOR_STATUS: {
190 192 ndmp_door_put_int32(enc_ctx, NDMP_DOOR_SRV_SUCCESS);
191 193 break;
192 194 }
193 195 case NDMP_DEVICES_GET_INFO: {
194 196 ndmp_door_put_int32(enc_ctx, NDMP_DOOR_SRV_SUCCESS);
195 197 ndmpd_get_devs(enc_ctx);
196 198 break;
197 199 }
198 200 case NDMP_SHOW: {
199 201 ndmp_door_put_int32(enc_ctx, NDMP_DOOR_SRV_SUCCESS);
200 202 ndmp_connect_list_get(enc_ctx);
201 203 break;
202 204 }
203 205 case NDMP_TERMINATE_SESSION_ID: {
204 206 int status, id;
205 207 id = ndmp_door_get_int32(dec_ctx);
206 208 status = ndmpd_connect_kill_id(id);
207 209 if (status == -1) /* session not found */
208 210 ndmp_door_put_int32(enc_ctx,
209 211 NDMP_DOOR_SRV_SUCCESS);
210 212 else
211 213 ndmp_door_put_int32(enc_ctx,
212 214 NDMP_DOOR_SRV_SUCCESS);
213 215 ndmp_door_put_int32(enc_ctx, status);
214 216 break;
215 217 }
216 218
217 219 case NDMP_GET_STAT:
218 220 ndmp_door_put_int32(enc_ctx, NDMP_DOOR_SRV_SUCCESS);
219 221 ndmp_door_put_uint32(enc_ctx, ndstat.ns_trun);
220 222 ndmp_door_put_uint32(enc_ctx, ndstat.ns_twait);
221 223 ndmp_door_put_uint32(enc_ctx, ndstat.ns_nbk);
|
↓ open down ↓ |
25 lines elided |
↑ open up ↑ |
222 224 ndmp_door_put_uint32(enc_ctx, ndstat.ns_nrs);
223 225 ndmp_door_put_uint32(enc_ctx, ndstat.ns_rfile);
224 226 ndmp_door_put_uint32(enc_ctx, ndstat.ns_wfile);
225 227 ndmp_door_put_uint64(enc_ctx, ndstat.ns_rdisk);
226 228 ndmp_door_put_uint64(enc_ctx, ndstat.ns_wdisk);
227 229 ndmp_door_put_uint64(enc_ctx, ndstat.ns_rtape);
228 230 ndmp_door_put_uint64(enc_ctx, ndstat.ns_wtape);
229 231 break;
230 232
231 233 default:
232 - NDMP_LOG(LOG_DEBUG,
234 + syslog(LOG_ERR,
233 235 "ndmp_door_server: Invalid request type 0x%x", req_type);
234 236 goto decode_error;
235 237 }
236 238
237 239 if ((dec_status = ndmp_door_decode_finish(dec_ctx)) != 0)
238 240 goto decode_error;
239 241
240 242 if ((enc_status = ndmp_door_encode_finish(enc_ctx, &used)) != 0)
241 243 goto encode_error;
242 244
243 245 (void) door_return(buf, used, NULL, 0);
244 246
245 247 return;
246 248
247 249 decode_error:
248 250 ndmp_door_put_int32(enc_ctx, NDMP_DOOR_SRV_ERROR);
249 251 ndmp_door_put_uint32(enc_ctx, dec_status);
250 252 (void) ndmp_door_encode_finish(enc_ctx, &used);
251 253 (void) door_return(buf, used, NULL, 0);
252 254 return;
253 255
254 256 encode_error:
255 257 enc_ctx = ndmp_door_encode_start(buf, buflen);
256 258 ndmp_door_put_int32(enc_ctx, NDMP_DOOR_SRV_ERROR);
257 259 ndmp_door_put_uint32(enc_ctx, enc_status);
258 260 (void) ndmp_door_encode_finish(enc_ctx, &used);
259 261 (void) door_return(buf, used, NULL, 0);
260 262 }
|
↓ open down ↓ |
18 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX