1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Copyright 2018 Nexenta Systems, Inc. 29 */ 30 31 #include <sys/param.h> 32 #include <sys/types.h> 33 #include <sys/pathname.h> 34 #include <sys/errno.h> 35 #include <sys/cmn_err.h> 36 #include <sys/debug.h> 37 #include <sys/systm.h> 38 #include <sys/unistd.h> 39 #include <sys/door.h> 40 #include <sys/socket.h> 41 #include <nfs/export.h> 42 #include <nfs/nfs_cmd.h> 43 #include <sys/kmem.h> 44 #include <sys/sunddi.h> 45 46 #define NFSCMD_DR_TRYCNT 8 47 48 #ifdef nextdp 49 #undef nextdp 50 #endif 51 #define nextdp(dp) ((struct dirent64 *)((char *)(dp) + (dp)->d_reclen)) 52 53 typedef struct nfscmd_globals { 54 kmutex_t nfscmd_lock; 55 door_handle_t nfscmd_dh; 56 } nfscmd_globals_t; 57 58 static zone_key_t nfscmd_zone_key; 59 60 static struct charset_cache *nfscmd_charmap(exportinfo_t *exi, 61 struct sockaddr *sp); 62 static void *nfscmd_zone_init(zoneid_t); 63 static void nfscmd_zone_fini(zoneid_t, void *); 64 65 void 66 nfscmd_args(uint_t did) 67 { 68 nfscmd_globals_t *ncg = zone_getspecific(nfscmd_zone_key, curzone); 69 70 mutex_enter(&ncg->nfscmd_lock); 71 if (ncg->nfscmd_dh != NULL) 72 door_ki_rele(ncg->nfscmd_dh); 73 ncg->nfscmd_dh = door_ki_lookup(did); 74 mutex_exit(&ncg->nfscmd_lock); 75 } 76 77 void 78 nfscmd_init(void) 79 { 80 zone_key_create(&nfscmd_zone_key, nfscmd_zone_init, 81 NULL, nfscmd_zone_fini); 82 } 83 84 void 85 nfscmd_fini(void) 86 { 87 (void) zone_key_delete(nfscmd_zone_key); 88 } 89 90 /*ARGSUSED*/ 91 static void * 92 nfscmd_zone_init(zoneid_t zoneid) 93 { 94 nfscmd_globals_t *ncg; 95 96 ncg = kmem_zalloc(sizeof (*ncg), KM_SLEEP); 97 mutex_init(&ncg->nfscmd_lock, NULL, MUTEX_DEFAULT, NULL); 98 99 return (ncg); 100 } 101 102 /*ARGSUSED*/ 103 static void 104 nfscmd_zone_fini(zoneid_t zoneid, void *data) 105 { 106 nfscmd_globals_t *ncg = data; 107 108 mutex_destroy(&ncg->nfscmd_lock); 109 if (ncg->nfscmd_dh) 110 door_ki_rele(ncg->nfscmd_dh); 111 kmem_free(ncg, sizeof (*ncg)); 112 } 113 114 /* 115 * nfscmd_send(arg, result) 116 * 117 * Send a command to the daemon listening on the door. The result is 118 * returned in the result pointer if the function return value is 119 * NFSCMD_ERR_SUCCESS. Otherwise it is the error value. 120 */ 121 int 122 nfscmd_send(nfscmd_arg_t *arg, nfscmd_res_t *res) 123 { 124 door_handle_t dh; 125 door_arg_t da; 126 door_info_t di; 127 int ntries = 0; 128 int last = 0; 129 nfscmd_globals_t *ncg = zone_getspecific(nfscmd_zone_key, curzone); 130 131 retry: 132 mutex_enter(&ncg->nfscmd_lock); 133 dh = ncg->nfscmd_dh; 134 if (dh != NULL) 135 door_ki_hold(dh); 136 mutex_exit(&ncg->nfscmd_lock); 137 138 if (dh == NULL) { 139 /* 140 * The rendezvous point has not been established yet ! 141 * This could mean that either mountd(1m) has not yet 142 * been started or that _this_ routine nuked the door 143 * handle after receiving an EINTR for a REVOKED door. 144 * 145 * Returning NFSAUTH_DROP will cause the NFS client 146 * to retransmit the request, so let's try to be more 147 * rescillient and attempt for ntries before we bail. 148 */ 149 if (++ntries % NFSCMD_DR_TRYCNT) { 150 delay(hz); 151 goto retry; 152 } 153 return (NFSCMD_ERR_DROP); 154 } 155 156 da.data_ptr = (char *)arg; 157 da.data_size = sizeof (nfscmd_arg_t); 158 da.desc_ptr = NULL; 159 da.desc_num = 0; 160 da.rbuf = (char *)res; 161 da.rsize = sizeof (nfscmd_res_t); 162 163 switch (door_ki_upcall(dh, &da)) { 164 case 0: 165 /* Success */ 166 break; 167 case EAGAIN: 168 /* Need to retry a couple of times */ 169 door_ki_rele(dh); 170 delay(hz); 171 goto retry; 172 /* NOTREACHED */ 173 case EINTR: 174 if (!door_ki_info(dh, &di)) { 175 if (di.di_attributes & DOOR_REVOKED) { 176 /* 177 * The server barfed and revoked 178 * the (existing) door on us; we 179 * want to wait to give smf(5) a 180 * chance to restart mountd(1m) 181 * and establish a new door handle. 182 */ 183 mutex_enter(&ncg->nfscmd_lock); 184 if (dh == ncg->nfscmd_dh) 185 ncg->nfscmd_dh = NULL; 186 mutex_exit(&ncg->nfscmd_lock); 187 door_ki_rele(dh); 188 delay(hz); 189 goto retry; 190 } 191 /* 192 * If the door was _not_ revoked on us, 193 * then more than likely we took an INTR, 194 * so we need to fail the operation. 195 */ 196 door_ki_rele(dh); 197 } 198 /* 199 * The only failure that can occur from getting 200 * the door info is EINVAL, so we let the code 201 * below handle it. 202 */ 203 /* FALLTHROUGH */ 204 205 case EBADF: 206 case EINVAL: 207 default: 208 /* 209 * If we have a stale door handle, give smf a last 210 * chance to start it by sleeping for a little bit. 211 * If we're still hosed, we'll fail the call. 212 * 213 * Since we're going to reacquire the door handle 214 * upon the retry, we opt to sleep for a bit and 215 * _not_ to clear mountd_dh. If mountd restarted 216 * and was able to set mountd_dh, we should see 217 * the new instance; if not, we won't get caught 218 * up in the retry/DELAY loop. 219 */ 220 door_ki_rele(dh); 221 if (!last) { 222 delay(hz); 223 last++; 224 goto retry; 225 } 226 res->error = NFSCMD_ERR_FAIL; 227 break; 228 } 229 return (res->error); 230 } 231 232 /* 233 * nfscmd_findmap(export, addr) 234 * 235 * Find a characterset map for the specified client address. 236 * First try to find a cached entry. If not successful, 237 * ask mountd daemon running in userland. 238 * 239 * For most of the clients this function is NOOP, since 240 * EX_CHARMAP flag won't be set. 241 */ 242 struct charset_cache * 243 nfscmd_findmap(struct exportinfo *exi, struct sockaddr *sp) 244 { 245 struct charset_cache *charset; 246 247 /* 248 * In debug kernel we want to know about strayed nulls. 249 * In non-debug kernel we behave gracefully. 250 */ 251 ASSERT(exi != NULL); 252 ASSERT(sp != NULL); 253 254 if (exi == NULL || sp == NULL) 255 return (NULL); 256 257 mutex_enter(&exi->exi_lock); 258 259 if (!(exi->exi_export.ex_flags & EX_CHARMAP)) { 260 mutex_exit(&exi->exi_lock); 261 return (NULL); 262 } 263 264 for (charset = exi->exi_charset; 265 charset != NULL; 266 charset = charset->next) { 267 if (bcmp(sp, &charset->client_addr, 268 sizeof (struct sockaddr)) == 0) 269 break; 270 } 271 mutex_exit(&exi->exi_lock); 272 273 /* the slooow way - ask daemon */ 274 if (charset == NULL) 275 charset = nfscmd_charmap(exi, sp); 276 277 return (charset); 278 } 279 280 /* 281 * nfscmd_insert_charmap(export, addr, name) 282 * 283 * Insert a new character set conversion map into the export structure 284 * for the share. The entry has the IP address of the client and the 285 * character set name. 286 */ 287 288 static struct charset_cache * 289 nfscmd_insert_charmap(struct exportinfo *exi, struct sockaddr *sp, char *name) 290 { 291 struct charset_cache *charset; 292 293 charset = (struct charset_cache *) 294 kmem_zalloc(sizeof (struct charset_cache), KM_SLEEP); 295 296 if (charset == NULL) 297 return (NULL); 298 if (name != NULL) { 299 charset->inbound = kiconv_open("UTF-8", name); 300 charset->outbound = kiconv_open(name, "UTF-8"); 301 } 302 charset->client_addr = *sp; 303 mutex_enter(&exi->exi_lock); 304 charset->next = exi->exi_charset; 305 exi->exi_charset = charset; 306 mutex_exit(&exi->exi_lock); 307 308 return (charset); 309 } 310 311 /* 312 * nfscmd_charmap(response, sp, exi) 313 * 314 * Check to see if this client needs a character set conversion. 315 */ 316 static struct charset_cache * 317 nfscmd_charmap(exportinfo_t *exi, struct sockaddr *sp) 318 { 319 nfscmd_arg_t req; 320 int ret; 321 char *path; 322 nfscmd_res_t res; 323 struct charset_cache *charset; 324 325 path = exi->exi_export.ex_path; 326 if (path == NULL) 327 return (NULL); 328 329 /* 330 * nfscmd_findmap() did not find one in the cache so make 331 * the request to the daemon. We need to add the entry in 332 * either case since we want negative as well as 333 * positive cacheing. 334 */ 335 req.cmd = NFSCMD_CHARMAP_LOOKUP; 336 req.version = NFSCMD_VERSION; 337 req.arg.charmap.addr = *sp; 338 (void) strncpy(req.arg.charmap.path, path, MAXPATHLEN); 339 bzero((caddr_t)&res, sizeof (nfscmd_res_t)); 340 ret = nfscmd_send(&req, &res); 341 if (ret == NFSCMD_ERR_SUCCESS) 342 charset = nfscmd_insert_charmap(exi, sp, 343 res.result.charmap.codeset); 344 else 345 charset = nfscmd_insert_charmap(exi, sp, NULL); 346 347 return (charset); 348 } 349 350 /* 351 * nfscmd_convname(addr, export, name, inbound, size) 352 * 353 * Convert the given "name" string to the appropriate character set. 354 * If inbound is true, convert from the client character set to UTF-8. 355 * If inbound is false, convert from UTF-8 to the client characters set. 356 * 357 * In case of NFS v4 this is used for ill behaved clients, since 358 * according to the standard all file names should be utf-8 encoded 359 * on client-side. 360 */ 361 362 char * 363 nfscmd_convname(struct sockaddr *ca, struct exportinfo *exi, char *name, 364 int inbound, size_t size) 365 { 366 char *newname; 367 char *holdname; 368 int err; 369 int ret; 370 size_t nsize; 371 size_t osize; 372 struct charset_cache *charset = NULL; 373 374 charset = nfscmd_findmap(exi, ca); 375 if (charset == NULL || 376 (charset->inbound == NULL && inbound) || 377 (charset->outbound == NULL && !inbound)) 378 return (name); 379 380 /* make sure we have more than enough space */ 381 newname = kmem_zalloc(size, KM_SLEEP); 382 nsize = strlen(name); 383 osize = size; 384 holdname = newname; 385 if (inbound) 386 ret = kiconv(charset->inbound, &name, &nsize, 387 &holdname, &osize, &err); 388 else 389 ret = kiconv(charset->outbound, &name, &nsize, 390 &holdname, &osize, &err); 391 if (ret == (size_t)-1) { 392 kmem_free(newname, size); 393 newname = NULL; 394 } 395 396 return (newname); 397 } 398 399 /* 400 * nfscmd_convdirent() 401 * 402 * There is only one entry in the data. Convert to new charset, if 403 * required and only return a success if it fits. 404 */ 405 char * 406 nfscmd_convdirent(struct sockaddr *ca, struct exportinfo *exi, char *data, 407 size_t size, enum nfsstat3 *error) 408 { 409 char *newdata; 410 size_t ret; 411 size_t nsize; 412 size_t count; 413 int err = 0; 414 char *iname; 415 char *oname; 416 struct charset_cache *charset; 417 418 charset = nfscmd_findmap(exi, ca); 419 if (charset == NULL || charset->outbound == (void *)~0) 420 return (data); 421 422 newdata = kmem_zalloc(size, KM_SLEEP); 423 424 nsize = strlen(((struct dirent64 *)data)->d_name); 425 count = size; 426 bcopy(data, newdata, sizeof (struct dirent64)); 427 428 iname = ((struct dirent64 *)data)->d_name; 429 oname = ((struct dirent64 *)newdata)->d_name; 430 431 ret = kiconv(charset->outbound, &iname, &nsize, &oname, &count, &err); 432 if (ret == (size_t)-1) { 433 kmem_free(newdata, size); 434 newdata = NULL; 435 if (err == E2BIG) { 436 if (error != NULL) 437 *error = NFS3ERR_NAMETOOLONG; 438 } else { 439 newdata = data; 440 } 441 } else { 442 ret = strlen(((struct dirent64 *)newdata)->d_name); 443 ((struct dirent64 *)newdata)->d_reclen = 444 DIRENT64_RECLEN(ret + 1); 445 } 446 return (newdata); 447 } 448 449 /* 450 * nfscmd_convdirplus(addr, export, data, nents, maxsize, ndata) 451 * 452 * Convert the dirents in data into a new list of dirents in ndata. 453 */ 454 455 size_t 456 nfscmd_convdirplus(struct sockaddr *ca, struct exportinfo *exi, char *data, 457 size_t nents, size_t maxsize, char **ndata) 458 { 459 char *newdata; 460 size_t nsize; 461 struct dirent64 *dp; 462 struct dirent64 *ndp; 463 size_t i; 464 size_t ret; 465 char *iname; 466 char *oname; 467 size_t ilen; 468 size_t olen; 469 int err; 470 size_t skipped; 471 struct charset_cache *charset; 472 *ndata = data; /* return the data if no changes to make */ 473 474 charset = nfscmd_findmap(exi, ca); 475 476 if (charset == NULL || charset->outbound == (void *)~0) 477 return (0); 478 479 newdata = kmem_zalloc(maxsize, KM_SLEEP); 480 nsize = 0; 481 482 dp = (struct dirent64 *)data; 483 ndp = (struct dirent64 *)newdata; 484 485 for (skipped = 0, i = 0; i < nents; i++) { 486 /* 487 * Copy the dp information if it fits. Then copy and 488 * convert the name in the entry. 489 */ 490 if ((maxsize - nsize) < dp->d_reclen) 491 /* doesn't fit */ 492 break; 493 *ndp = *dp; 494 iname = dp->d_name; 495 ilen = strlen(iname); 496 oname = ndp->d_name; 497 olen = MIN(MAXNAMELEN, maxsize - nsize); 498 ret = kiconv(charset->outbound, &iname, &ilen, &oname, 499 &olen, &err); 500 501 if (ret == (size_t)-1) { 502 switch (err) { 503 default: 504 case E2BIG: 505 break; 506 case EILSEQ: 507 skipped++; 508 dp = nextdp(dp); 509 continue; 510 } 511 } 512 ilen = MIN(MAXNAMELEN, maxsize - nsize) - olen; 513 ndp->d_name[ilen] = '\0'; 514 /* 515 * What to do with other errors? 516 * For now, we return the unconverted string. 517 */ 518 ndp->d_reclen = DIRENT64_RECLEN(strlen(ndp->d_name) + 1); 519 nsize += ndp->d_reclen; 520 dp = nextdp(dp); 521 ndp = nextdp(ndp); 522 } 523 524 *ndata = newdata; 525 return (nents - (i + skipped)); 526 } 527 528 /* 529 * nfscmd_countents(data, len) 530 * 531 * How many dirents are there in the data buffer? 532 */ 533 534 size_t 535 nfscmd_countents(char *data, size_t len) 536 { 537 struct dirent64 *dp = (struct dirent64 *)data; 538 size_t curlen; 539 size_t reclen; 540 size_t nents; 541 542 for (nents = 0, curlen = 0; curlen < len; curlen += reclen, nents++) { 543 reclen = dp->d_reclen; 544 dp = nextdp(dp); 545 } 546 return (nents); 547 } 548 549 /* 550 * nfscmd_dropped_entrysize(dir, drop, nents) 551 * 552 * We need to drop "drop" entries from dir in order to fit in the 553 * buffer. How much do we reduce the overall size by? 554 */ 555 556 size_t 557 nfscmd_dropped_entrysize(struct dirent64 *dir, size_t drop, size_t nents) 558 { 559 size_t size; 560 size_t i; 561 562 for (i = nents - drop; i > 0 && dir != NULL; i--) 563 dir = nextdp(dir); 564 565 if (dir == NULL) 566 return (0); 567 568 for (size = 0, i = 0; i < drop && dir != NULL; i++) { 569 size += dir->d_reclen; 570 dir = nextdp(dir); 571 } 572 return (size); 573 } 574