autofs-5.0.2-dynamic-logging.patch

   1 diff --git a/CHANGELOG b/CHANGELOG
   2 index ca171a4..a7ac9fb 100644
   3 --- a/CHANGELOG
   4 +++ b/CHANGELOG
   5 @@ -35,6 +35,7 @@
   6  - fix typo in autofs(5) man page.
   7  - fix map entry expansion when undefined macro is present.
   8  - remove unused export validation code.
   9 +- add dynamic logging (adapted from v4 patch from Jeff Moyer).
  10
  11  18/06/2007 autofs-5.0.2
  12  -----------------------
  13 diff --git a/daemon/automount.c b/daemon/automount.c
  14 index 70a3b9d..9ec6923 100644
  15 --- a/daemon/automount.c
  16 +++ b/daemon/automount.c
  17 @@ -173,7 +173,7 @@ int rmdir_path(struct autofs_point *ap, const char *path, dev_t dev)
  18                  */
  19                 memset(&st, 0, sizeof(st));
  20                 if (lstat(buf, &st) != 0) {
  21 -                       crit(ap->logopt, "lstat of %s failed.", buf);
  22 +                       crit(ap->logopt, "lstat of %s failed", buf);
  23                         return -1;
  24                 }
  25
  26 @@ -234,14 +234,15 @@ int rmdir_path(struct autofs_point *ap, const char *path, dev_t dev)
  27  /* Like ftw, except fn gets called twice: before a directory is
  28     entered, and after.  If the before call returns 0, the directory
  29     isn't entered. */
  30 -static int walk_tree(const char *base, int (*fn) (const char *file,
  31 +static int walk_tree(const char *base, int (*fn) (unsigned logopt,
  32 +                                                 const char *file,
  33                                                   const struct stat * st,
  34 -                                                 int, void *), int incl, void *arg)
  35 +                                                 int, void *), int incl, unsigned logopt, void *arg)
  36  {
  37         char buf[PATH_MAX + 1];
  38         struct stat st;
  39
  40 -       if (lstat(base, &st) != -1 && (fn) (base, &st, 0, arg)) {
  41 +       if (lstat(base, &st) != -1 && (fn) (logopt, base, &st, 0, arg)) {
  42                 if (S_ISDIR(st.st_mode)) {
  43                         struct dirent **de;
  44                         int n;
  45 @@ -269,18 +270,18 @@ static int walk_tree(const char *base, int (*fn) (const char *file,
  46                                         return -1;
  47                                 }
  48
  49 -                               walk_tree(buf, fn, 1, arg);
  50 +                               walk_tree(buf, fn, 1, logopt, arg);
  51                                 free(de[n]);
  52                         }
  53                         free(de);
  54                 }
  55                 if (incl)
  56 -                       (fn) (base, &st, 1, arg);
  57 +                       (fn) (logopt, base, &st, 1, arg);
  58         }
  59         return 0;
  60  }
  61
  62 -static int rm_unwanted_fn(const char *file, const struct stat *st, int when, void *arg)
  63 +static int rm_unwanted_fn(unsigned logopt, const char *file, const struct stat *st, int when, void *arg)
  64  {
  65         dev_t dev = *(dev_t *) arg;
  66         char buf[MAX_ERR_BUF];
  67 @@ -293,41 +294,38 @@ static int rm_unwanted_fn(const char *file, const struct stat *st, int when, voi
  68         }
  69
  70         if (lstat(file, &newst)) {
  71 -               crit(LOGOPT_ANY,
  72 -                    "unable to stat file, possible race condition");
  73 +               crit(logopt, "unable to stat file, possible race condition");
  74                 return 0;
  75         }
  76
  77         if (newst.st_dev != dev) {
  78 -               crit(LOGOPT_ANY,
  79 -                    "file %s has the wrong device, possible race condition",
  80 +               crit(logopt, "file %s has the wrong device, possible race condition",
  81                      file);
  82                 return 0;
  83         }
  84
  85         if (S_ISDIR(newst.st_mode)) {
  86 -               debug(LOGOPT_ANY, "removing directory %s", file);
  87 +               debug(logopt, "removing directory %s", file);
  88                 if (rmdir(file)) {
  89                         char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
  90 -                       warn(LOGOPT_ANY,
  91 +                       warn(logopt,
  92                               "unable to remove directory %s: %s", file, estr);
  93                         return 0;
  94                 }
  95         } else if (S_ISREG(newst.st_mode)) {
  96 -               crit(LOGOPT_ANY,
  97 -                    "attempting to remove files from a mounted "
  98 +               crit(logopt, "attempting to remove files from a mounted "
  99                      "directory. file %s", file);
 100                 return 0;
 101         } else if (S_ISLNK(newst.st_mode)) {
 102 -               debug(LOGOPT_ANY, "removing symlink %s", file);
 103 +               debug(logopt, "removing symlink %s", file);
 104                 unlink(file);
 105         }
 106         return 1;
 107  }
 108
 109 -void rm_unwanted(const char *path, int incl, dev_t dev)
 110 +void rm_unwanted(unsigned logopt, const char *path, int incl, dev_t dev)
 111  {
 112 -       walk_tree(path, rm_unwanted_fn, incl, &dev);
 113 +       walk_tree(path, rm_unwanted_fn, incl, logopt, &dev);
 114  }
 115
 116  struct counter_args {
 117 @@ -335,7 +333,7 @@ struct counter_args {
 118         dev_t dev;
 119  };
 120
 121 -static int counter_fn(const char *file, const struct stat *st, int when, void *arg)
 122 +static int counter_fn(unsigned logopt, const char *file, const struct stat *st, int when, void *arg)
 123  {
 124         struct counter_args *counter = (struct counter_args *) arg;
 125
 126 @@ -349,14 +347,14 @@ static int counter_fn(const char *file, const struct stat *st, int when, void *a
 127  }
 128
 129  /* Count mounted filesystems and symlinks */
 130 -int count_mounts(const char *path, dev_t dev)
 131 +int count_mounts(unsigned logopt, const char *path, dev_t dev)
 132  {
 133         struct counter_args counter;
 134
 135         counter.count = 0;
 136         counter.dev = dev;
 137
 138 -       if (walk_tree(path, counter_fn, 0, &counter) == -1)
 139 +       if (walk_tree(path, counter_fn, 0, logopt, &counter) == -1)
 140                 return -1;
 141
 142         return counter.count;
 143 @@ -368,9 +366,9 @@ static void check_rm_dirs(struct autofs_point *ap, const char *path, int incl)
 144             (ap->state == ST_SHUTDOWN_PENDING ||
 145              ap->state == ST_SHUTDOWN_FORCE ||
 146              ap->state == ST_SHUTDOWN))
 147 -               rm_unwanted(path, incl, ap->dev);
 148 +               rm_unwanted(ap->logopt, path, incl, ap->dev);
 149         else if (ap->ghost && (ap->type == LKP_INDIRECT))
 150 -               rm_unwanted(path, 0, ap->dev);
 151 +               rm_unwanted(ap->logopt, path, 0, ap->dev);
 152  }
 153
 154  /* Try to purge cache entries kept around due to existing mounts */
 155 @@ -466,7 +464,7 @@ static int umount_subtree_mounts(struct autofs_point *ap, const char *path, unsi
 156                 cache_multi_lock(me->parent);
 157                 if (umount_multi_triggers(ap, root, me, base)) {
 158                         warn(ap->logopt,
 159 -                            "could not umount some offsets under %s", path);
 160 +                            "some offset mounts still present under %s", path);
 161                         left++;
 162                 }
 163                 cache_multi_unlock(me->parent);
 164 @@ -483,7 +481,7 @@ static int umount_subtree_mounts(struct autofs_point *ap, const char *path, unsi
 165          * it already to ensure it's ok to remove any offset triggers.
 166          */
 167         if (!is_mm_root && is_mounted(_PATH_MOUNTED, path, MNTS_REAL)) {
 168 -               msg("unmounting dir = %s", path);
 169 +               info(ap->logopt, "unmounting dir = %s", path);
 170                 if (umount_ent(ap, path)) {
 171                         warn(ap->logopt, "could not umount dir %s", path);
 172                         left++;
 173 @@ -576,35 +574,35 @@ int umount_autofs(struct autofs_point *ap, int force)
 174         return ret;
 175  }
 176
 177 -int send_ready(int ioctlfd, unsigned int wait_queue_token)
 178 +int send_ready(unsigned logopt, int ioctlfd, unsigned int wait_queue_token)
 179  {
 180         char buf[MAX_ERR_BUF];
 181
 182         if (wait_queue_token == 0)
 183                 return 0;
 184
 185 -       debug(LOGOPT_NONE, "token = %d", wait_queue_token);
 186 +       debug(logopt, "token = %d", wait_queue_token);
 187
 188         if (ioctl(ioctlfd, AUTOFS_IOC_READY, wait_queue_token) < 0) {
 189                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
 190 -               error(LOGOPT_ANY, "AUTOFS_IOC_READY: error %s", estr);
 191 +               logerr("AUTOFS_IOC_READY: error %s", estr);
 192                 return 1;
 193         }
 194         return 0;
 195  }
 196
 197 -int send_fail(int ioctlfd, unsigned int wait_queue_token)
 198 +int send_fail(unsigned logopt, int ioctlfd, unsigned int wait_queue_token)
 199  {
 200         char buf[MAX_ERR_BUF];
 201
 202         if (wait_queue_token == 0)
 203                 return 0;
 204
 205 -       debug(LOGOPT_NONE, "token = %d", wait_queue_token);
 206 +       debug(logopt, "token = %d", wait_queue_token);
 207
 208         if (ioctl(ioctlfd, AUTOFS_IOC_FAIL, wait_queue_token) < 0) {
 209                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
 210 -               error(LOGOPT_ANY, "AUTOFS_IOC_FAIL: error %s", estr);
 211 +               logerr("AUTOFS_IOC_FAIL: error %s", estr);
 212                 return 1;
 213         }
 214         return 0;
 215 @@ -649,23 +647,245 @@ static int fullread(int fd, void *ptr, size_t len)
 216         return len;
 217  }
 218
 219 +static char *automount_path_to_fifo(unsigned logopt, const char *path)
 220 +{
 221 +       char *fifo_name, *p;
 222 +       int  name_len = strlen(path) + strlen(AUTOFS_LOGPRI_FIFO) + 1;
 223 +       int ret;
 224 +
 225 +       fifo_name = malloc(name_len);
 226 +       if (!fifo_name)
 227 +               return NULL;
 228 +       ret = snprintf(fifo_name, name_len, "%s%s",
 229 +                      AUTOFS_LOGPRI_FIFO, path);
 230 +       if (ret >= name_len) {
 231 +               info(logopt,
 232 +                    "fifo path for \"%s\" truncated to \"%s\".  This may "
 233 +                    "lead to --set-log-priority commands being sent to the "
 234 +                    "wrong automount daemon.", path, fifo_name);
 235 +       }
 236 +
 237 +       /*
 238 +        *  An automount path can be made up of subdirectories.  So, to
 239 +        *  create the fifo name, we will just replace instances of '/' with
 240 +        *  '-'.
 241 +        */
 242 +       p = fifo_name + strlen(AUTOFS_LOGPRI_FIFO);
 243 +       while (*p != '\0') {
 244 +               if (*p == '/')
 245 +                       *p = '-';
 246 +               p++;
 247 +       }
 248 +
 249 +       debug(logopt, "fifo name %s",fifo_name);
 250 +
 251 +       return fifo_name;
 252 +}
 253 +
 254 +static int create_logpri_fifo(struct autofs_point *ap)
 255 +{
 256 +       int ret = -1;
 257 +       int fd;
 258 +       char *fifo_name;
 259 +
 260 +       fifo_name = automount_path_to_fifo(ap->logopt, ap->path);
 261 +       if (!fifo_name) {
 262 +               crit(ap->logopt, "Failed to allocate memory!");
 263 +               goto out_free; /* free(NULL) is okay */
 264 +       }
 265 +
 266 +       ret = unlink(fifo_name);
 267 +       if (ret != 0 && errno != ENOENT) {
 268 +               crit(ap->logopt,
 269 +                    "Failed to unlink FIFO. Is the automount daemon "
 270 +                    "already running?");
 271 +               goto out_free;
 272 +       }
 273 +
 274 +       ret = mkfifo(fifo_name, S_IRUSR|S_IWUSR);
 275 +       if (ret != 0) {
 276 +               crit(ap->logopt,
 277 +                    "mkfifo for %s returned %d", fifo_name, errno);
 278 +               goto out_free;
 279 +       }
 280 +
 281 +       fd = open(fifo_name, O_RDWR|O_NONBLOCK);
 282 +       if (fd < 0) {
 283 +               crit(ap->logopt,
 284 +                    "Failed to open %s, errno %d", fifo_name, errno);
 285 +               goto out_free;
 286 +       }
 287 +
 288 +       ap->logpri_fifo = fd;
 289 +
 290 +out_free:
 291 +       free(fifo_name);
 292 +       return ret;
 293 +}
 294 +
 295 +static int destroy_logpri_fifo(struct autofs_point *ap)
 296 +{
 297 +       int ret = -1;
 298 +       int fd = ap->logpri_fifo;
 299 +       char *fifo_name;
 300 +
 301 +       fifo_name = automount_path_to_fifo(ap->logopt, ap->path);
 302 +       if (!fifo_name) {
 303 +               crit(ap->logopt, "Failed to allocate memory!");
 304 +               goto out_free; /* free(NULL) is okay */
 305 +       }
 306 +
 307 +       ap->logpri_fifo = -1;
 308 +
 309 +       ret = close(fd);
 310 +       if (ret != 0) {
 311 +               warn(ap->logopt,
 312 +                    "close for fifo %s returned %d", fifo_name, errno);
 313 +       }
 314 +
 315 +       ret = unlink(fifo_name);
 316 +       if (ret != 0) {
 317 +               warn(ap->logopt,
 318 +                    "Failed to unlink FIFO. Was the fifo created OK?");
 319 +       }
 320 +
 321 +out_free:
 322 +       free(fifo_name);
 323 +       return ret;
 324 +}
 325 +
 326 +static void handle_fifo_message(struct autofs_point *ap, int fd)
 327 +{
 328 +       int ret;
 329 +       char buffer[PIPE_BUF];
 330 +       char *end;
 331 +       long pri;
 332 +
 333 +       memset(buffer, 0, sizeof(buffer));
 334 +       ret = read(fd, &buffer, sizeof(buffer));
 335 +       if (ret < 0) {
 336 +               warn(ap->logopt, "read on fifo returned error %d", errno);
 337 +               return;
 338 +       }
 339 +
 340 +       if (ret != 2) {
 341 +               debug(ap->logopt, "expected 2 bytes, received %d.", ret);
 342 +               return;
 343 +       }
 344 +
 345 +       errno = 0;
 346 +       pri = strtol(buffer, &end, 10);
 347 +       if ((pri == LONG_MIN || pri == LONG_MAX) && errno == ERANGE) {
 348 +               debug(ap->logopt, "strtol reported an %s.  Failed to set "
 349 +                     "log priority.", pri == LONG_MIN ? "underflow" : "overflow");
 350 +               return;
 351 +       }
 352 +       if ((pri == 0 && errno == EINVAL) || end == buffer) {
 353 +               debug(ap->logopt, "priority is expected to be an integer "
 354 +                     "in the range 0-7 inclusive.");
 355 +               return;
 356 +       }
 357 +
 358 +       if (pri > LOG_DEBUG || pri < LOG_EMERG) {
 359 +               debug(ap->logopt, "invalid log priority (%ld) received "
 360 +                     "on fifo", pri);
 361 +               return;
 362 +       }
 363 +
 364 +       /*
 365 +        * OK, the message passed all of the sanity checks.  The
 366 +        * automounter actually only supports three log priorities.
 367 +        * Everything is logged at log level debug, deamon messages
 368 +        * and everything except debug messages are logged with the
 369 +        * verbose setting and only error and critical messages are
 370 +        * logged when debugging isn't enabled.
 371 +        */
 372 +       if (pri >= LOG_WARNING) {
 373 +               if (pri == LOG_DEBUG) {
 374 +                       set_log_debug_ap(ap);
 375 +                       info(ap->logopt, "Debug logging set for %s", ap->path);
 376 +               } else {
 377 +                       set_log_verbose_ap(ap);
 378 +                       info(ap->logopt, "Verbose logging set for %s", ap->path);
 379 +               }
 380 +       } else {
 381 +               if (ap->logopt & LOGOPT_ANY)
 382 +                       info(ap->logopt, "Basic logging set for %s", ap->path);
 383 +               set_log_norm_ap(ap);
 384 +       }
 385 +}
 386 +
 387 +static int set_log_priority(const char *path, int priority)
 388 +{
 389 +       int fd;
 390 +       char *fifo_name;
 391 +       char buf[2];
 392 +
 393 +       if (priority > LOG_DEBUG || priority < LOG_EMERG) {
 394 +               fprintf(stderr, "Log priority %d is invalid.\n", priority);
 395 +               fprintf(stderr, "Please spcify a number in the range 0-7.\n");
 396 +               return -1;
 397 +       }
 398 +
 399 +       /*
 400 +        * This is an ascii based protocol, so we want the string
 401 +        * representation of the integer log priority.
 402 +        */
 403 +       snprintf(buf, sizeof(buf), "%d", priority);
 404 +
 405 +       fifo_name = automount_path_to_fifo(LOGOPT_NONE, path);
 406 +       if (!fifo_name) {
 407 +               fprintf(stderr, "%s: Failed to allocate memory!\n",
 408 +                       __FUNCTION__);
 409 +               return -1;
 410 +       }
 411 +
 412 +       /*
 413 +        * Specify O_NONBLOCK so that the open will fail if there is no
 414 +        * daemon reading from the other side of the FIFO.
 415 +        */
 416 +       fd = open(fifo_name, O_WRONLY|O_NONBLOCK);
 417 +       if (fd < 0) {
 418 +               fprintf(stderr, "%s: open of %s failed with %d\n",
 419 +                       __FUNCTION__, fifo_name, errno);
 420 +               free(fifo_name);
 421 +               return -1;
 422 +       }
 423 +
 424 +       if (write(fd, buf, sizeof(buf)) != sizeof(buf)) {
 425 +               fprintf(stderr, "Failed to change logging priority.  ");
 426 +               fprintf(stderr, "write to fifo failed with errno %d.\n",
 427 +                       errno);
 428 +               close(fd);
 429 +               free(fifo_name);
 430 +               return -1;
 431 +       }
 432 +       close(fd);
 433 +       free(fifo_name);
 434 +       fprintf(stdout, "Successfully set log priority for %s.\n", path);
 435 +
 436 +       return 0;
 437 +}
 438 +
 439  static int get_pkt(struct autofs_point *ap, union autofs_packet_union *pkt)
 440  {
 441 -       struct pollfd fds[2];
 442 +       struct pollfd fds[3];
 443         char buf[MAX_ERR_BUF];
 444
 445         fds[0].fd = ap->pipefd;
 446         fds[0].events = POLLIN;
 447         fds[1].fd = ap->state_pipe[0];
 448         fds[1].events = POLLIN;
 449 +       fds[2].fd = ap->logpri_fifo;
 450 +       fds[2].events = POLLIN;
 451
 452         for (;;) {
 453 -               if (poll(fds, 2, -1) == -1) {
 454 +               if (poll(fds, 3, -1) == -1) {
 455                         char *estr;
 456                         if (errno == EINTR)
 457                                 continue;
 458                         estr = strerror_r(errno, buf, MAX_ERR_BUF);
 459 -                       error(ap->logopt, "poll failed: %s", estr);
 460 +                       logerr("poll failed: %s", estr);
 461                         return -1;
 462                 }
 463
 464 @@ -709,6 +929,11 @@ static int get_pkt(struct autofs_point *ap, union autofs_packet_union *pkt)
 465
 466                 if (fds[0].revents & POLLIN)
 467                         return fullread(ap->pipefd, pkt, kpkt_len);
 468 +
 469 +               if (fds[2].revents & POLLIN) {
 470 +                       debug(ap->logopt, "message pending on control fifo.");
 471 +                       handle_fifo_message(ap, fds[2].fd);
 472 +               }
 473         }
 474  }
 475
 476 @@ -730,21 +955,93 @@ int do_expire(struct autofs_point *ap, const char *name, int namelen)
 477                 return 1;
 478         }
 479
 480 -       msg("expiring path %s", buf);
 481 +       info(ap->logopt, "expiring path %s", buf);
 482
 483         ret = umount_multi(ap, buf, 1);
 484         if (ret == 0)
 485 -               msg("expired %s", buf);
 486 +               info(ap->logopt, "expired %s", buf);
 487         else
 488                 warn(ap->logopt, "couldn't complete expire of %s", buf);
 489
 490         return ret;
 491  }
 492
 493 +static int autofs_init_ap(struct autofs_point *ap)
 494 +{
 495 +       int pipefd[2], cl_flags;
 496 +
 497 +       if ((ap->state != ST_INIT)) {
 498 +               /* This can happen if an autofs process is already running*/
 499 +               error(ap->logopt, "bad state %d", ap->state);
 500 +               return -1;
 501 +       }
 502 +
 503 +       ap->pipefd = ap->kpipefd = ap->ioctlfd = -1;
 504 +
 505 +       /* Pipe for kernel communications */
 506 +       if (pipe(pipefd) < 0) {
 507 +               crit(ap->logopt,
 508 +                    "failed to create commumication pipe for autofs path %s",
 509 +                    ap->path);
 510 +               free(ap->path);
 511 +               return -1;
 512 +       }
 513 +
 514 +       ap->pipefd = pipefd[0];
 515 +       ap->kpipefd = pipefd[1];
 516 +
 517 +       if ((cl_flags = fcntl(ap->pipefd, F_GETFD, 0)) != -1) {
 518 +               cl_flags |= FD_CLOEXEC;
 519 +               fcntl(ap->pipefd, F_SETFD, cl_flags);
 520 +       }
 521 +
 522 +       if ((cl_flags = fcntl(ap->kpipefd, F_GETFD, 0)) != -1) {
 523 +               cl_flags |= FD_CLOEXEC;
 524 +               fcntl(ap->kpipefd, F_SETFD, cl_flags);
 525 +       }
 526 +
 527 +       /* Pipe state changes from signal handler to main loop */
 528 +       if (pipe(ap->state_pipe) < 0) {
 529 +               crit(ap->logopt,
 530 +                    "failed create state pipe for autofs path %s", ap->path);
 531 +               close(ap->pipefd);
 532 +               close(ap->kpipefd);     /* Close kernel pipe end */
 533 +               free(ap->path);
 534 +               return -1;
 535 +       }
 536 +
 537 +       if ((cl_flags = fcntl(ap->state_pipe[0], F_GETFD, 0)) != -1) {
 538 +               cl_flags |= FD_CLOEXEC;
 539 +               fcntl(ap->state_pipe[0], F_SETFD, cl_flags);
 540 +       }
 541 +
 542 +       if ((cl_flags = fcntl(ap->state_pipe[1], F_GETFD, 0)) != -1) {
 543 +               cl_flags |= FD_CLOEXEC;
 544 +               fcntl(ap->state_pipe[1], F_SETFD, cl_flags);
 545 +       }
 546 +
 547 +       if (create_logpri_fifo(ap) < 0) {
 548 +               crit(ap->logopt,
 549 +                    "failed to create FIFO for path %s\n", ap->path);
 550 +               destroy_logpri_fifo(ap);
 551 +               close(ap->pipefd);
 552 +               close(ap->kpipefd);
 553 +               free(ap->path);
 554 +               close(ap->state_pipe[0]);
 555 +               close(ap->state_pipe[1]);
 556 +               return -1;
 557 +       }
 558 +
 559 +       return 0;
 560 +}
 561 +
 562  static int mount_autofs(struct autofs_point *ap)
 563  {
 564         int status = 0;
 565
 566 +       if (autofs_init_ap(ap) != 0)
 567 +               return -1;
 568 +
 569         if (ap->type == LKP_DIRECT)
 570                 status = mount_autofs_direct(ap);
 571         else
 572 @@ -841,9 +1138,8 @@ static void become_daemon(unsigned foreground)
 573                         fclose(pidfp);
 574                 } else {
 575                         char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
 576 -                       warn(LOGOPT_ANY,
 577 -                            "failed to write pid file %s: %s",
 578 -                            pid_file, estr);
 579 +                       logerr("failed to write pid file %s: %s",
 580 +                              pid_file, estr);
 581                         pid_file = NULL;
 582                 }
 583         }
 584 @@ -889,12 +1185,12 @@ static void *do_notify_state(void *arg)
 585
 586         master = mrc.master;
 587
 588 -       debug(master->default_logging, "signal %d", sig);
 589 +       debug(master->logopt, "signal %d", sig);
 590
 591         mrc.signaled = 1;
 592         status = pthread_cond_signal(&mrc.cond);
 593         if (status) {
 594 -               error(master->default_logging,
 595 +               error(master->logopt,
 596                       "failed to signal state notify condition");
 597                 status = pthread_mutex_unlock(&mrc.mutex);
 598                 if (status)
 599 @@ -923,7 +1219,7 @@ static pthread_t do_signals(struct master *master, int sig)
 600
 601         status = pthread_create(&thid, &thread_attr, do_notify_state, &r_sig);
 602         if (status) {
 603 -               error(master->default_logging,
 604 +               error(master->logopt,
 605                       "mount state notify thread create failed");
 606                 status = pthread_mutex_unlock(&mrc.mutex);
 607                 if (status)
 608 @@ -951,6 +1247,7 @@ static pthread_t do_signals(struct master *master, int sig)
 609  static void *do_read_master(void *arg)
 610  {
 611         struct master *master;
 612 +       unsigned int logopt;
 613         time_t age;
 614         int readall = 1;
 615         int status;
 616 @@ -961,11 +1258,12 @@ static void *do_read_master(void *arg)
 617
 618         master = mrc.master;
 619         age = mrc.age;
 620 +       logopt = master->logopt;
 621
 622         mrc.signaled = 1;
 623         status = pthread_cond_signal(&mrc.cond);
 624         if (status) {
 625 -               error(master->default_logging,
 626 +               error(logopt,
 627                       "failed to signal master read map condition");
 628                 master->reading = 0;
 629                 status = pthread_mutex_unlock(&mrc.mutex);
 630 @@ -989,6 +1287,7 @@ static void *do_read_master(void *arg)
 631
 632  static int do_hup_signal(struct master *master, time_t age)
 633  {
 634 +       unsigned int logopt = master->logopt;
 635         pthread_t thid;
 636         int status;
 637
 638 @@ -1007,7 +1306,7 @@ static int do_hup_signal(struct master *master, time_t age)
 639
 640         status = pthread_create(&thid, &thread_attr, do_read_master, NULL);
 641         if (status) {
 642 -               error(master->default_logging,
 643 +               error(logopt,
 644                       "master read map thread create failed");
 645                 master->reading = 0;
 646                 status = pthread_mutex_unlock(&mrc.mutex);
 647 @@ -1062,8 +1361,7 @@ static void *statemachine(void *arg)
 648                         break;
 649
 650                 default:
 651 -                       error(master_list->default_logging,
 652 -                             "got unexpected signal %d!", sig);
 653 +                       logerr("got unexpected signal %d!", sig);
 654                         continue;
 655                 }
 656         }
 657 @@ -1134,10 +1432,11 @@ static void handle_mounts_cleanup(void *arg)
 658         struct autofs_point *ap;
 659         char path[PATH_MAX + 1];
 660         char buf[MAX_ERR_BUF];
 661 -       unsigned int clean = 0, submount;
 662 +       unsigned int clean = 0, submount, logopt;
 663
 664         ap = (struct autofs_point *) arg;
 665
 666 +       logopt = ap->logopt;
 667         submount = ap->submount;
 668
 669         strcpy(path, ap->path);
 670 @@ -1152,6 +1451,7 @@ static void handle_mounts_cleanup(void *arg)
 671
 672         umount_autofs(ap, 1);
 673
 674 +       destroy_logpri_fifo(ap);
 675         master_signal_submount(ap, MASTER_SUBMNT_JOIN);
 676         master_remove_mapent(ap->entry);
 677         master_free_mapent_sources(ap->entry, 1);
 678 @@ -1162,12 +1462,12 @@ static void handle_mounts_cleanup(void *arg)
 679         if (clean) {
 680                 if (rmdir(path) == -1) {
 681                         char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
 682 -                       warn(LOGOPT_NONE, "failed to remove dir %s: %s",
 683 +                       warn(logopt, "failed to remove dir %s: %s",
 684                              path, estr);
 685                 }
 686         }
 687
 688 -       msg("shut down path %s", path);
 689 +       info(logopt, "shut down path %s", path);
 690
 691         /* If we are the last tell the state machine to shutdown */
 692         if (!submount && master_list_empty(master_list))
 693 @@ -1190,7 +1490,7 @@ void *handle_mounts(void *arg)
 694
 695         status = pthread_mutex_lock(&suc.mutex);
 696         if (status) {
 697 -               crit(ap->logopt, "failed to lock startup condition mutex!");
 698 +               logerr("failed to lock startup condition mutex!");
 699                 fatal(status);
 700         }
 701
 702 @@ -1204,7 +1504,7 @@ void *handle_mounts(void *arg)
 703         }
 704
 705         if (ap->ghost && ap->type != LKP_DIRECT)
 706 -               msg("ghosting enabled");
 707 +               info(ap->logopt, "ghosting enabled");
 708
 709         suc.status = 0;
 710         pthread_cleanup_pop(1);
 711 @@ -1356,6 +1656,8 @@ static void usage(void)
 712                 "                       use ramdom replicated server selection\n"
 713                 "       -O --global-options\n"
 714                 "                       specify global mount options\n"
 715 +               "       -l --set-log-priority priority path [path,...]\n"
 716 +               "                       set daemon log verbosity\n"
 717                 "       -V --version    print version, build config and exit\n"
 718                 , program);
 719  }
 720 @@ -1437,9 +1739,45 @@ static void show_build_info(void)
 721         return;
 722  }
 723
 724 +typedef struct _code {
 725 +       char    *c_name;
 726 +       int     c_val;
 727 +} CODE;
 728 +
 729 +CODE prioritynames[] = {
 730 +       { "alert",      LOG_ALERT },
 731 +       { "crit",       LOG_CRIT },
 732 +       { "debug",      LOG_DEBUG },
 733 +       { "emerg",      LOG_EMERG },
 734 +       { "err",        LOG_ERR },
 735 +       { "error",      LOG_ERR },              /* DEPRECATED */
 736 +       { "info",       LOG_INFO },
 737 +       { "notice",     LOG_NOTICE },
 738 +       { "panic",      LOG_EMERG },            /* DEPRECATED */
 739 +       { "warn",       LOG_WARNING },          /* DEPRECATED */
 740 +       { "warning",    LOG_WARNING },
 741 +       { NULL,         -1 },
 742 +};
 743 +
 744 +static int convert_log_priority(char *priority_name)
 745 +{
 746 +       CODE *priority_mapping;
 747 +
 748 +       for (priority_mapping = prioritynames;
 749 +            priority_mapping->c_name != NULL;
 750 +            priority_mapping++) {
 751 +
 752 +               if (!strcasecmp(priority_name, priority_mapping->c_name))
 753 +                       return priority_mapping->c_val;
 754 +       }
 755 +
 756 +       return -1;
 757 +}
 758 +
 759  int main(int argc, char *argv[])
 760  {
 761         int res, opt, status;
 762 +       int logpri = -1;
 763         unsigned ghost, logging;
 764         unsigned foreground, have_global_options;
 765         time_t timeout;
 766 @@ -1457,6 +1795,7 @@ int main(int argc, char *argv[])
 767                 {"random-multimount-selection", 0, 0, 'r'},
 768                 {"global-options", 1, 0, 'O'},
 769                 {"version", 0, 0, 'V'},
 770 +               {"set-log-priority", 1, 0, 'l'},
 771                 {0, 0, 0, 0}
 772         };
 773
 774 @@ -1477,7 +1816,7 @@ int main(int argc, char *argv[])
 775         foreground = 0;
 776
 777         opterr = 0;
 778 -       while ((opt = getopt_long(argc, argv, "+hp:t:vdD:fVrO:", long_options, NULL)) != EOF) {
 779 +       while ((opt = getopt_long(argc, argv, "+hp:t:vdD:fVrO:l:", long_options, NULL)) != EOF) {
 780                 switch (opt) {
 781                 case 'h':
 782                         usage();
 783 @@ -1525,6 +1864,23 @@ int main(int argc, char *argv[])
 784                                 program);
 785                         break;
 786
 787 +               case 'l':
 788 +                       if (isalpha(*optarg)) {
 789 +                               logpri = convert_log_priority(optarg);
 790 +                               if (logpri < 0) {
 791 +                                       fprintf(stderr, "Invalid log priority:"
 792 +                                               " %s\n", optarg);
 793 +                                       exit(1);
 794 +                               }
 795 +                       } else if (isdigit(*optarg)) {
 796 +                               logpri = getnumopt(optarg, opt);
 797 +                       } else {
 798 +                               fprintf(stderr, "non-alphanumeric character "
 799 +                                       "found in log priority.  Aborting.\n");
 800 +                               exit(1);
 801 +                       }
 802 +                       break;
 803 +
 804                 case '?':
 805                 case ':':
 806                         printf("%s: Ambiguous or unknown options\n", program);
 807 @@ -1548,6 +1904,26 @@ int main(int argc, char *argv[])
 808         argv += optind;
 809         argc -= optind;
 810
 811 +       if (logpri >= 0) {
 812 +               int exit_code = 0;
 813 +               int i;
 814 +
 815 +               /*
 816 +                * The remaining argv elements are the paths for which
 817 +                * log priorities must be changed.
 818 +                */
 819 +               for (i = 0; i < argc; i++) {
 820 +                       if (set_log_priority(argv[i], logpri) < 0)
 821 +                               exit_code = 1;
 822 +               }
 823 +               if (argc < 1) {
 824 +                       fprintf(stderr,
 825 +                               "--set-log-priority requires a path.\n");
 826 +                       exit_code = 1;
 827 +               }
 828 +               exit(exit_code);
 829 +       }
 830 +
 831         if (is_automount_running() > 0) {
 832                 fprintf(stderr, "%s: program is already running.\n",
 833                         program);
 834 @@ -1572,7 +1948,7 @@ int main(int argc, char *argv[])
 835         rlim.rlim_max = MAX_OPEN_FILES;
 836         res = setrlimit(RLIMIT_NOFILE, &rlim);
 837         if (res)
 838 -               warn(LOGOPT_NONE,
 839 +               warn(logging,
 840                      "can't increase open file limit - continuing");
 841
 842  #if ENABLE_CORES
 843 @@ -1580,7 +1956,7 @@ int main(int argc, char *argv[])
 844         rlim.rlim_max = RLIM_INFINITY;
 845         res = setrlimit(RLIMIT_CORE, &rlim);
 846         if (res)
 847 -               warn(LOGOPT_NONE,
 848 +               warn(logging,
 849                      "can't increase core file limit - continuing");
 850  #endif
 851
 852 @@ -1592,15 +1968,14 @@ int main(int argc, char *argv[])
 853                 master_list = master_new(argv[0], timeout, ghost);
 854
 855         if (!master_list) {
 856 -               crit(LOGOPT_ANY, "%s: can't create master map %s",
 857 +               logerr("%s: can't create master map %s",
 858                         program, argv[0]);
 859                 close(start_pipefd[1]);
 860                 exit(1);
 861         }
 862
 863         if (pthread_attr_init(&thread_attr)) {
 864 -               crit(LOGOPT_ANY,
 865 -                    "%s: failed to init thread attribute struct!",
 866 +               logerr("%s: failed to init thread attribute struct!",
 867                      program);
 868                 close(start_pipefd[1]);
 869                 exit(1);
 870 @@ -1608,8 +1983,7 @@ int main(int argc, char *argv[])
 871
 872         if (pthread_attr_setdetachstate(
 873                         &thread_attr, PTHREAD_CREATE_DETACHED)) {
 874 -               crit(LOGOPT_ANY,
 875 -                    "%s: failed to set detached thread attribute!",
 876 +               logerr("%s: failed to set detached thread attribute!",
 877                      program);
 878                 close(start_pipefd[1]);
 879                 exit(1);
 880 @@ -1618,38 +1992,37 @@ int main(int argc, char *argv[])
 881  #ifdef _POSIX_THREAD_ATTR_STACKSIZE
 882         if (pthread_attr_setstacksize(
 883                         &thread_attr, PTHREAD_STACK_MIN*64)) {
 884 -               crit(LOGOPT_ANY,
 885 -                    "%s: failed to set stack size thread attribute!",
 886 -                    program);
 887 +               logerr("%s: failed to set stack size thread attribute!",
 888 +                      program);
 889                 close(start_pipefd[1]);
 890                 exit(1);
 891         }
 892  #endif
 893
 894 -       msg("Starting automounter version %s, master map %s",
 895 +       info(logging, "Starting automounter version %s, master map %s",
 896                 version, master_list->name);
 897 -       msg("using kernel protocol version %d.%02d",
 898 +       info(logging, "using kernel protocol version %d.%02d",
 899                 get_kver_major(), get_kver_minor());
 900
 901         status = pthread_key_create(&key_thread_stdenv_vars,
 902                                 key_thread_stdenv_vars_destroy);
 903         if (status) {
 904 -               crit(LOGOPT_ANY,
 905 -                    "failed to create thread data key for std env vars!");
 906 +               logerr("%s: failed to create thread data key for std env vars!",
 907 +                      program);
 908                 master_kill(master_list);
 909                 close(start_pipefd[1]);
 910                 exit(1);
 911         }
 912
 913         if (!alarm_start_handler()) {
 914 -               crit(LOGOPT_ANY, "failed to create alarm handler thread!");
 915 +               logerr("%s: failed to create alarm handler thread!", program);
 916                 master_kill(master_list);
 917                 close(start_pipefd[1]);
 918                 exit(1);
 919         }
 920
 921         if (!st_start_handler()) {
 922 -               crit(LOGOPT_ANY, "failed to create FSM handler thread!");
 923 +               logerr("%s: failed to create FSM handler thread!", program);
 924                 master_kill(master_list);
 925                 close(start_pipefd[1]);
 926                 exit(1);
 927 @@ -1685,5 +2058,7 @@ int main(int argc, char *argv[])
 928         if (dh)
 929                 dlclose(dh);
 930  #endif
 931 +       info(logging, "autofs stopped");
 932 +
 933         exit(0);
 934  }
 935 diff --git a/daemon/direct.c b/daemon/direct.c
 936 index 9a39a6f..4ab4204 100644
 937 --- a/daemon/direct.c
 938 +++ b/daemon/direct.c
 939 @@ -86,61 +86,6 @@ static void mnts_cleanup(void *arg)
 940         return;
 941  }
 942
 943 -static int autofs_init_direct(struct autofs_point *ap)
 944 -{
 945 -       int pipefd[2], cl_flags;
 946 -
 947 -       if ((ap->state != ST_INIT)) {
 948 -               /* This can happen if an autofs process is already running*/
 949 -               error(ap->logopt, "bad state %d", ap->state);
 950 -               return -1;
 951 -       }
 952 -
 953 -       ap->pipefd = ap->kpipefd = ap->ioctlfd = -1;
 954 -
 955 -       /* Pipe for kernel communications */
 956 -       if (pipe(pipefd) < 0) {
 957 -               crit(ap->logopt,
 958 -                    "failed to create commumication pipe for autofs path %s",
 959 -                    ap->path);
 960 -               return -1;
 961 -       }
 962 -
 963 -       ap->pipefd = pipefd[0];
 964 -       ap->kpipefd = pipefd[1];
 965 -
 966 -       if ((cl_flags = fcntl(ap->pipefd, F_GETFD, 0)) != -1) {
 967 -               cl_flags |= FD_CLOEXEC;
 968 -               fcntl(ap->pipefd, F_SETFD, cl_flags);
 969 -       }
 970 -
 971 -       if ((cl_flags = fcntl(ap->kpipefd, F_GETFD, 0)) != -1) {
 972 -               cl_flags |= FD_CLOEXEC;
 973 -               fcntl(ap->kpipefd, F_SETFD, cl_flags);
 974 -       }
 975 -
 976 -       /* Pipe state changes from signal handler to main loop */
 977 -       if (pipe(ap->state_pipe) < 0) {
 978 -               crit(ap->logopt, "failed create state pipe for autofs path %s",
 979 -                    ap->path);
 980 -               close(ap->pipefd);
 981 -               close(ap->kpipefd);
 982 -               return -1;
 983 -       }
 984 -
 985 -       if ((cl_flags = fcntl(ap->state_pipe[0], F_GETFD, 0)) != -1) {
 986 -               cl_flags |= FD_CLOEXEC;
 987 -               fcntl(ap->state_pipe[0], F_SETFD, cl_flags);
 988 -       }
 989 -
 990 -       if ((cl_flags = fcntl(ap->state_pipe[1], F_GETFD, 0)) != -1) {
 991 -               cl_flags |= FD_CLOEXEC;
 992 -               fcntl(ap->state_pipe[1], F_SETFD, cl_flags);
 993 -       }
 994 -
 995 -       return 0;
 996 -}
 997 -
 998  int do_umount_autofs_direct(struct autofs_point *ap, struct mnt_list *mnts, struct mapent *me)
 999  {
1000         char buf[MAX_ERR_BUF];
1001 @@ -241,10 +186,10 @@ int do_umount_autofs_direct(struct autofs_point *ap, struct mnt_list *mnts, stru
1002
1003  force_umount:
1004         if (rv != 0) {
1005 -               msg("forcing umount of direct mount %s", me->key);
1006 +               info(ap->logopt, "forcing umount of direct mount %s", me->key);
1007                 rv = umount2(me->key, MNT_DETACH);
1008         } else
1009 -               msg("umounted direct mount %s", me->key);
1010 +               info(ap->logopt, "umounted direct mount %s", me->key);
1011
1012         if (!rv && me->dir_created) {
1013                 if  (rmdir(me->key) == -1) {
1014 @@ -326,7 +271,7 @@ static int unlink_mount_tree(struct autofs_point *ap, struct list_head *list)
1015                         continue;
1016
1017                 if (strcmp(mnt->fs_type, "autofs"))
1018 -                       rv = spawn_umount(log_debug, "-l", mnt->path, NULL);
1019 +                       rv = spawn_umount(ap->logopt, "-l", mnt->path, NULL);
1020                 else
1021                         rv = umount2(mnt->path, MNT_DETACH);
1022                 if (rv == -1) {
1023 @@ -475,13 +420,15 @@ int do_mount_autofs_direct(struct autofs_point *ap, struct mnt_list *mnts, struc
1024         ioctl(ioctlfd, AUTOFS_IOC_SETTIMEOUT, &timeout);
1025
1026         if (ap->exp_timeout)
1027 -               msg("mounted direct mount on %s "
1028 +               info(ap->logopt,
1029 +                   "mounted direct mount on %s "
1030                     "with timeout %u, freq %u seconds", me->key,
1031                     (unsigned int) ap->exp_timeout,
1032                     (unsigned int) ap->exp_runfreq);
1033         else
1034 -               msg("mounted direct mount on %s with timeouts disabled",
1035 -                   me->key);
1036 +               info(ap->logopt,
1037 +                    "mounted direct mount on %s with timeouts disabled",
1038 +                    me->key);
1039
1040         ret = fstat(ioctlfd, &st);
1041         if (ret == -1) {
1042 @@ -522,9 +469,6 @@ int mount_autofs_direct(struct autofs_point *ap)
1043                 return -1;
1044         }
1045
1046 -       if (autofs_init_direct(ap))
1047 -               return -1;
1048 -
1049         /* TODO: check map type */
1050         if (lookup_nss_read_map(ap, NULL, now))
1051                 lookup_prune_cache(ap, now);
1052 @@ -607,7 +551,7 @@ int umount_autofs_offset(struct autofs_point *ap, struct mapent *me)
1053                 /* offset isn't mounted, return success and try to recover */
1054                 if (!is_mounted(_PROC_MOUNTS, me->key, MNTS_AUTOFS)) {
1055                         debug(ap->logopt,
1056 -                             "offset %s unexpectedly not mounted",
1057 +                             "offset %s not mounted",
1058                               me->key);
1059                         return 0;
1060                 }
1061 @@ -627,7 +571,7 @@ int umount_autofs_offset(struct autofs_point *ap, struct mapent *me)
1062                 rv = ioctl(ioctlfd, AUTOFS_IOC_ASKUMOUNT, &status);
1063                 if (rv) {
1064                         char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1065 -                       error(ap->logopt, "ioctl failed: %s", estr);
1066 +                       logerr("ioctl failed: %s", estr);
1067                         return 1;
1068                 } else if (!status) {
1069                         if (ap->state != ST_SHUTDOWN_FORCE) {
1070 @@ -692,10 +636,10 @@ int umount_autofs_offset(struct autofs_point *ap, struct mapent *me)
1071
1072  force_umount:
1073         if (rv != 0) {
1074 -               msg("forcing umount of offset mount %s", me->key);
1075 +               info(ap->logopt, "forcing umount of offset mount %s", me->key);
1076                 rv = umount2(me->key, MNT_DETACH);
1077         } else
1078 -               msg("umounted offset mount %s", me->key);
1079 +               info(ap->logopt, "umounted offset mount %s", me->key);
1080
1081         if (!rv && me->dir_created) {
1082                 if  (rmdir(me->key) == -1) {
1083 @@ -868,7 +812,7 @@ static int expire_direct(int ioctlfd, const char *path, unsigned int when, unsig
1084                 return 0;
1085         }
1086
1087 -       retries = (count_mounts(path, st.st_dev) + 1) * EXPIRE_RETRIES;
1088 +       retries = (count_mounts(logopt, path, st.st_dev) + 1) * EXPIRE_RETRIES;
1089
1090         while (retries--) {
1091                 struct timespec tm = {0, 100000000};
1092 @@ -1018,7 +962,7 @@ void *expire_proc_direct(void *arg)
1093
1094                         if (me->ioctlfd != -1 &&
1095                             fstat(ioctlfd, &st) != -1 &&
1096 -                           !count_mounts(next->path, st.st_dev)) {
1097 +                           !count_mounts(ap->logopt, next->path, st.st_dev)) {
1098                                 close(ioctlfd);
1099                                 me->ioctlfd = -1;
1100                         }
1101 @@ -1049,6 +993,9 @@ void *expire_proc_direct(void *arg)
1102         }
1103         pthread_cleanup_pop(1);
1104
1105 +       if (left)
1106 +               info(ap->logopt, "%d remaining in %s", left, ap->path);
1107 +
1108         ec.status = left;
1109
1110         pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);
1111 @@ -1072,7 +1019,7 @@ static void pending_cond_destroy(void *arg)
1112  static void expire_send_fail(void *arg)
1113  {
1114         struct pending_args *mt = arg;
1115 -       send_fail(mt->ioctlfd, mt->wait_queue_token);
1116 +       send_fail(mt->ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1117  }
1118
1119  static void free_pending_args(void *arg)
1120 @@ -1124,14 +1071,14 @@ static void *do_expire_direct(void *arg)
1121         status = do_expire(ap, mt->name, len);
1122         pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);
1123         if (status)
1124 -               send_fail(mt->ioctlfd, mt->wait_queue_token);
1125 +               send_fail(ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1126         else {
1127                 struct mapent *me;
1128                 cache_readlock(mt->mc);
1129                 me = cache_lookup_distinct(mt->mc, mt->name);
1130                 me->ioctlfd = -1;
1131                 cache_unlock(mt->mc);
1132 -               send_ready(mt->ioctlfd, mt->wait_queue_token);
1133 +               send_ready(ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1134                 close(mt->ioctlfd);
1135         }
1136         pthread_setcancelstate(state, NULL);
1137 @@ -1194,7 +1141,7 @@ int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_di
1138         if (!mt) {
1139                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1140                 error(ap->logopt, "malloc: %s", estr);
1141 -               send_fail(me->ioctlfd, pkt->wait_queue_token);
1142 +               send_fail(ap->logopt, me->ioctlfd, pkt->wait_queue_token);
1143                 cache_unlock(mc);
1144                 pthread_setcancelstate(state, NULL);
1145                 return 1;
1146 @@ -1223,7 +1170,7 @@ int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_di
1147         status = pthread_create(&thid, &thread_attr, do_expire_direct, mt);
1148         if (status) {
1149                 error(ap->logopt, "expire thread create failed");
1150 -               send_fail(mt->ioctlfd, pkt->wait_queue_token);
1151 +               send_fail(ap->logopt, mt->ioctlfd, pkt->wait_queue_token);
1152                 cache_unlock(mc);
1153                 expire_mutex_unlock(NULL);
1154                 pending_cond_destroy(mt);
1155 @@ -1252,7 +1199,7 @@ int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_di
1156  static void mount_send_fail(void *arg)
1157  {
1158         struct pending_args *mt = arg;
1159 -       send_fail(mt->ioctlfd, mt->wait_queue_token);
1160 +       send_fail(mt->ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1161         close(mt->ioctlfd);
1162  }
1163
1164 @@ -1319,7 +1266,7 @@ static void *do_mount_direct(void *arg)
1165
1166         pthread_setcancelstate(state, NULL);
1167
1168 -       msg("attempting to mount entry %s", mt->name);
1169 +       info(ap->logopt, "attempting to mount entry %s", mt->name);
1170
1171         /*
1172          * Setup thread specific data values for macro
1173 @@ -1445,16 +1392,16 @@ cont:
1174                 cache_unlock(mt->mc);
1175                 if (set_fd) {
1176                         me->ioctlfd = mt->ioctlfd;
1177 -                       send_ready(mt->ioctlfd, mt->wait_queue_token);
1178 +                       send_ready(ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1179                 } else {
1180 -                       send_ready(mt->ioctlfd, mt->wait_queue_token);
1181 +                       send_ready(ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1182                         close(mt->ioctlfd);
1183                 }
1184 -               msg("mounted %s", mt->name);
1185 +               info(ap->logopt, "mounted %s", mt->name);
1186         } else {
1187 -               send_fail(mt->ioctlfd, mt->wait_queue_token);
1188 +               send_fail(mt->ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1189                 close(mt->ioctlfd);
1190 -               msg("failed to mount %s", mt->name);
1191 +               info(ap->logopt, "failed to mount %s", mt->name);
1192         }
1193         pthread_setcancelstate(state, NULL);
1194
1195 @@ -1505,7 +1452,7 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_
1196                  * Shouldn't happen as the kernel is telling us
1197                  * someone has walked on our mount point.
1198                  */
1199 -               crit(ap->logopt, "can't find map entry for (%lu,%lu)",
1200 +               logerr("can't find map entry for (%lu,%lu)",
1201                     (unsigned long) pkt->dev, (unsigned long) pkt->ino);
1202                 pthread_setcancelstate(state, NULL);
1203                 return 1;
1204 @@ -1538,7 +1485,7 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_
1205         if (ap->state == ST_SHUTDOWN_PENDING ||
1206             ap->state == ST_SHUTDOWN_FORCE ||
1207             ap->state == ST_SHUTDOWN) {
1208 -               send_fail(ioctlfd, pkt->wait_queue_token);
1209 +               send_fail(ap->logopt, ioctlfd, pkt->wait_queue_token);
1210                 close(ioctlfd);
1211                 cache_unlock(mc);
1212                 pthread_setcancelstate(state, NULL);
1213 @@ -1549,7 +1496,7 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_
1214         if (!mt) {
1215                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1216                 error(ap->logopt, "malloc: %s", estr);
1217 -               send_fail(ioctlfd, pkt->wait_queue_token);
1218 +               send_fail(ap->logopt, ioctlfd, pkt->wait_queue_token);
1219                 close(ioctlfd);
1220                 cache_unlock(mc);
1221                 pthread_setcancelstate(state, NULL);
1222 @@ -1578,7 +1525,7 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_
1223         status = pthread_create(&thid, &thread_attr, do_mount_direct, mt);
1224         if (status) {
1225                 error(ap->logopt, "missing mount thread create failed");
1226 -               send_fail(ioctlfd, pkt->wait_queue_token);
1227 +               send_fail(ap->logopt, ioctlfd, pkt->wait_queue_token);
1228                 close(ioctlfd);
1229                 cache_unlock(mc);
1230                 mount_mutex_unlock(NULL);
1231 diff --git a/daemon/indirect.c b/daemon/indirect.c
1232 index 02e7045..5c422c8 100644
1233 --- a/daemon/indirect.c
1234 +++ b/daemon/indirect.c
1235 @@ -43,63 +43,6 @@ extern pthread_attr_t thread_attr;
1236  static pthread_mutex_t ma_mutex = PTHREAD_MUTEX_INITIALIZER;
1237  static pthread_mutex_t ea_mutex = PTHREAD_MUTEX_INITIALIZER;
1238
1239 -static int autofs_init_indirect(struct autofs_point *ap)
1240 -{
1241 -       int pipefd[2], cl_flags;
1242 -
1243 -       if ((ap->state != ST_INIT)) {
1244 -               /* This can happen if an autofs process is already running*/
1245 -               error(ap->logopt, "bad state %d", ap->state);
1246 -               return -1;
1247 -       }
1248 -
1249 -       ap->pipefd = ap->kpipefd = ap->ioctlfd = -1;
1250 -
1251 -       /* Pipe for kernel communications */
1252 -       if (pipe(pipefd) < 0) {
1253 -               crit(ap->logopt,
1254 -                    "failed to create commumication pipe for autofs path %s",
1255 -                    ap->path);
1256 -               free(ap->path);
1257 -               return -1;
1258 -       }
1259 -
1260 -       ap->pipefd = pipefd[0];
1261 -       ap->kpipefd = pipefd[1];
1262 -
1263 -       if ((cl_flags = fcntl(ap->pipefd, F_GETFD, 0)) != -1) {
1264 -               cl_flags |= FD_CLOEXEC;
1265 -               fcntl(ap->pipefd, F_SETFD, cl_flags);
1266 -       }
1267 -
1268 -       if ((cl_flags = fcntl(ap->kpipefd, F_GETFD, 0)) != -1) {
1269 -               cl_flags |= FD_CLOEXEC;
1270 -               fcntl(ap->kpipefd, F_SETFD, cl_flags);
1271 -       }
1272 -
1273 -       /* Pipe state changes from signal handler to main loop */
1274 -       if (pipe(ap->state_pipe) < 0) {
1275 -               crit(ap->logopt,
1276 -                    "failed create state pipe for autofs path %s", ap->path);
1277 -               close(ap->pipefd);
1278 -               close(ap->kpipefd);     /* Close kernel pipe end */
1279 -               free(ap->path);
1280 -               return -1;
1281 -       }
1282 -
1283 -       if ((cl_flags = fcntl(ap->state_pipe[0], F_GETFD, 0)) != -1) {
1284 -               cl_flags |= FD_CLOEXEC;
1285 -               fcntl(ap->state_pipe[0], F_SETFD, cl_flags);
1286 -       }
1287 -
1288 -       if ((cl_flags = fcntl(ap->state_pipe[1], F_GETFD, 0)) != -1) {
1289 -               cl_flags |= FD_CLOEXEC;
1290 -               fcntl(ap->state_pipe[1], F_SETFD, cl_flags);
1291 -       }
1292 -
1293 -       return 0;
1294 -}
1295 -
1296  static int unlink_mount_tree(struct autofs_point *ap, struct mnt_list *mnts)
1297  {
1298         struct mnt_list *this;
1299 @@ -118,7 +61,7 @@ static int unlink_mount_tree(struct autofs_point *ap, struct mnt_list *mnts)
1300                 }
1301
1302                 if (strcmp(this->fs_type, "autofs"))
1303 -                       rv = spawn_umount(log_debug, "-l", this->path, NULL);
1304 +                       rv = spawn_umount(ap->logopt, "-l", this->path, NULL);
1305                 else
1306                         rv = umount2(this->path, MNT_DETACH);
1307                 if (rv == -1) {
1308 @@ -222,12 +165,14 @@ static int do_mount_autofs_indirect(struct autofs_point *ap)
1309         ioctl(ap->ioctlfd, AUTOFS_IOC_SETTIMEOUT, &timeout);
1310
1311         if (ap->exp_timeout)
1312 -               msg("mounted indirect mount on %s "
1313 +               info(ap->logopt,
1314 +                   "mounted indirect mount on %s "
1315                     "with timeout %u, freq %u seconds", ap->path,
1316 -                  (unsigned int) ap->exp_timeout,
1317 -                  (unsigned int) ap->exp_runfreq);
1318 +                   (unsigned int) ap->exp_timeout,
1319 +                   (unsigned int) ap->exp_runfreq);
1320         else
1321 -               msg("mounted indirect mount on %s with timeouts disabled",
1322 +               info(ap->logopt,
1323 +                   "mounted indirect mount on %s with timeouts disabled",
1324                     ap->path);
1325
1326         fstat(ap->ioctlfd, &st);
1327 @@ -257,9 +202,6 @@ int mount_autofs_indirect(struct autofs_point *ap)
1328         int status;
1329         int map;
1330
1331 -        if (autofs_init_indirect(ap))
1332 -               return -1;
1333 -
1334         /* TODO: read map, determine map type is OK */
1335         if (lookup_nss_read_map(ap, NULL, now))
1336                 lookup_prune_cache(ap, now);
1337 @@ -309,7 +251,7 @@ int umount_autofs_indirect(struct autofs_point *ap)
1338         rv = ioctl(ap->ioctlfd, AUTOFS_IOC_ASKUMOUNT, &ret);
1339         if (rv == -1) {
1340                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1341 -               error(ap->logopt, "ioctl failed: %s", estr);
1342 +               logerr("ioctl failed: %s", estr);
1343                 return 1;
1344         } else if (!ret) {
1345                 error(ap->logopt, "ask umount returned busy %s", ap->path);
1346 @@ -370,9 +312,9 @@ force_umount:
1347                      "forcing umount of indirect mount %s", ap->path);
1348                 rv = umount2(ap->path, MNT_DETACH);
1349         } else {
1350 -               msg("umounted indirect mount %s", ap->path);
1351 +               info(ap->logopt, "umounted indirect mount %s", ap->path);
1352                 if (ap->submount)
1353 -                       rm_unwanted(ap->path, 1, ap->dev);
1354 +                       rm_unwanted(ap->logopt, ap->path, 1, ap->dev);
1355         }
1356
1357         return rv;
1358 @@ -390,7 +332,7 @@ static int expire_indirect(struct autofs_point *ap, int ioctlfd, const char *pat
1359                 return 0;
1360         }
1361
1362 -       retries = (count_mounts(path, st.st_dev) + 1) * EXPIRE_RETRIES;
1363 +       retries = (count_mounts(ap->logopt, path, st.st_dev) + 1) * EXPIRE_RETRIES;
1364
1365         while (retries--) {
1366                 struct timespec tm = {0, 100000000};
1367 @@ -559,13 +501,7 @@ void *expire_proc_indirect(void *arg)
1368          * words) the umounts are done by the time we reach here
1369          */
1370         if (count)
1371 -               debug(ap->logopt, "%d remaining in %s", count, ap->path);
1372 -
1373 -       /* If we are trying to shutdown make sure we can umount */
1374 -       if (!ioctl(ap->ioctlfd, AUTOFS_IOC_ASKUMOUNT, &ret)) {
1375 -               if (!ret)
1376 -                       msg("mount still busy %s", ap->path);
1377 -       }
1378 +               info(ap->logopt, "%d remaining in %s", count, ap->path);
1379
1380         ec.status = left;
1381
1382 @@ -590,7 +526,7 @@ static void pending_cond_destroy(void *arg)
1383  static void expire_send_fail(void *arg)
1384  {
1385         struct pending_args *mt = arg;
1386 -       send_fail(mt->ap->ioctlfd, mt->wait_queue_token);
1387 +       send_fail(mt->ap->logopt, mt->ap->ioctlfd, mt->wait_queue_token);
1388  }
1389
1390  static void free_pending_args(void *arg)
1391 @@ -634,9 +570,9 @@ static void *do_expire_indirect(void *arg)
1392         status = do_expire(mt->ap, mt->name, mt->len);
1393         pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);
1394         if (status)
1395 -               send_fail(ap->ioctlfd, mt->wait_queue_token);
1396 +               send_fail(ap->logopt, ap->ioctlfd, mt->wait_queue_token);
1397         else
1398 -               send_ready(ap->ioctlfd, mt->wait_queue_token);
1399 +               send_ready(ap->logopt, ap->ioctlfd, mt->wait_queue_token);
1400         pthread_setcancelstate(state, NULL);
1401
1402         pthread_cleanup_pop(0);
1403 @@ -661,8 +597,8 @@ int handle_packet_expire_indirect(struct autofs_point *ap, autofs_packet_expire_
1404         mt = malloc(sizeof(struct pending_args));
1405         if (!mt) {
1406                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1407 -               error(ap->logopt, "malloc: %s", estr);
1408 -               send_fail(ap->ioctlfd, pkt->wait_queue_token);
1409 +               logerr("malloc: %s", estr);
1410 +               send_fail(ap->logopt, ap->ioctlfd, pkt->wait_queue_token);
1411                 pthread_setcancelstate(state, NULL);
1412                 return 1;
1413         }
1414 @@ -684,7 +620,7 @@ int handle_packet_expire_indirect(struct autofs_point *ap, autofs_packet_expire_
1415         status = pthread_create(&thid, &thread_attr, do_expire_indirect, mt);
1416         if (status) {
1417                 error(ap->logopt, "expire thread create failed");
1418 -               send_fail(ap->ioctlfd, pkt->wait_queue_token);
1419 +               send_fail(ap->logopt, ap->ioctlfd, pkt->wait_queue_token);
1420                 expire_mutex_unlock(NULL);
1421                 pending_cond_destroy(mt);
1422                 free_pending_args(mt);
1423 @@ -710,7 +646,7 @@ int handle_packet_expire_indirect(struct autofs_point *ap, autofs_packet_expire_
1424  static void mount_send_fail(void *arg)
1425  {
1426         struct pending_args *mt = arg;
1427 -       send_fail(mt->ap->ioctlfd, mt->wait_queue_token);
1428 +       send_fail(mt->ap->logopt, mt->ap->ioctlfd, mt->wait_queue_token);
1429  }
1430
1431  static void mount_mutex_unlock(void *arg)
1432 @@ -775,7 +711,7 @@ static void *do_mount_indirect(void *arg)
1433
1434         pthread_setcancelstate(state, NULL);
1435
1436 -       msg("attempting to mount entry %s", buf);
1437 +       info(ap->logopt, "attempting to mount entry %s", buf);
1438
1439         /*
1440          * Setup thread specific data values for macro
1441 @@ -887,11 +823,11 @@ cont:
1442         status = lookup_nss_mount(ap, NULL, mt->name, mt->len);
1443         pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);
1444         if (status) {
1445 -               send_ready(ap->ioctlfd, mt->wait_queue_token);
1446 -               msg("mounted %s", buf);
1447 +               send_ready(ap->logopt, ap->ioctlfd, mt->wait_queue_token);
1448 +               info(ap->logopt, "mounted %s", buf);
1449         } else {
1450 -               send_fail(ap->ioctlfd, mt->wait_queue_token);
1451 -               msg("failed to mount %s", buf);
1452 +               send_fail(ap->logopt, ap->ioctlfd, mt->wait_queue_token);
1453 +               info(ap->logopt, "failed to mount %s", buf);
1454         }
1455         pthread_setcancelstate(state, NULL);
1456
1457 @@ -918,7 +854,7 @@ int handle_packet_missing_indirect(struct autofs_point *ap, autofs_packet_missin
1458         if (ap->state == ST_SHUTDOWN_PENDING ||
1459             ap->state == ST_SHUTDOWN_FORCE ||
1460             ap->state == ST_SHUTDOWN) {
1461 -               send_fail(ap->ioctlfd, pkt->wait_queue_token);
1462 +               send_fail(ap->logopt, ap->ioctlfd, pkt->wait_queue_token);
1463                 pthread_setcancelstate(state, NULL);
1464                 return 0;
1465         }
1466 @@ -926,8 +862,8 @@ int handle_packet_missing_indirect(struct autofs_point *ap, autofs_packet_missin
1467         mt = malloc(sizeof(struct pending_args));
1468         if (!mt) {
1469                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1470 -               error(ap->logopt, "malloc: %s", estr);
1471 -               send_fail(ap->ioctlfd, pkt->wait_queue_token);
1472 +               logerr("malloc: %s", estr);
1473 +               send_fail(ap->logopt, ap->ioctlfd, pkt->wait_queue_token);
1474                 pthread_setcancelstate(state, NULL);
1475                 return 1;
1476         }
1477 @@ -953,7 +889,7 @@ int handle_packet_missing_indirect(struct autofs_point *ap, autofs_packet_missin
1478         status = pthread_create(&thid, &thread_attr, do_mount_indirect, mt);
1479         if (status) {
1480                 error(ap->logopt, "expire thread create failed");
1481 -               send_fail(ap->ioctlfd, pkt->wait_queue_token);
1482 +               send_fail(ap->logopt, ap->ioctlfd, pkt->wait_queue_token);
1483                 mount_mutex_unlock(NULL);
1484                 pending_cond_destroy(mt);
1485                 free_pending_args(mt);
1486 diff --git a/daemon/lookup.c b/daemon/lookup.c
1487 index 4f2b318..fd99cf2 100644
1488 --- a/daemon/lookup.c
1489 +++ b/daemon/lookup.c
1490 @@ -103,6 +103,7 @@ static int do_read_master(struct master *master, char *type, time_t age)
1491
1492  static int read_master_map(struct master *master, char *type, time_t age)
1493  {
1494 +       unsigned int logopt = master->logopt;
1495         char *path, *save_name;
1496         int result;
1497
1498 @@ -117,7 +118,7 @@ static int read_master_map(struct master *master, char *type, time_t age)
1499          */
1500
1501         if (strchr(master->name, '/')) {
1502 -               error(LOGOPT_ANY, "relative path invalid in files map name");
1503 +               error(logopt, "relative path invalid in files map name");
1504                 return NSS_STATUS_NOTFOUND;
1505         }
1506
1507 @@ -142,6 +143,7 @@ static int read_master_map(struct master *master, char *type, time_t age)
1508
1509  int lookup_nss_read_master(struct master *master, time_t age)
1510  {
1511 +       unsigned int logopt = master->logopt;
1512         struct list_head nsslist;
1513         struct list_head *head, *p;
1514         int result = NSS_STATUS_UNKNOWN;
1515 @@ -149,12 +151,10 @@ int lookup_nss_read_master(struct master *master, time_t age)
1516         /* If it starts with a '/' it has to be a file or LDAP map */
1517         if (*master->name == '/') {
1518                 if (*(master->name + 1) == '/') {
1519 -                       debug(LOGOPT_NONE,
1520 -                             "reading master ldap %s", master->name);
1521 +                       debug(logopt, "reading master ldap %s", master->name);
1522                         result = do_read_master(master, "ldap", age);
1523                 } else {
1524 -                       debug(LOGOPT_NONE,
1525 -                             "reading master file %s", master->name);
1526 +                       debug(logopt, "reading master file %s", master->name);
1527                         result = do_read_master(master, "file", age);
1528                 }
1529
1530 @@ -184,13 +184,11 @@ int lookup_nss_read_master(struct master *master, time_t age)
1531                                  */
1532                                 if (strncmp(name, "ldap", 4)) {
1533                                         master->name = tmp + 1;
1534 -                                       debug(LOGOPT_NONE,
1535 -                                             "reading master %s %s",
1536 +                                       debug(logopt, "reading master %s %s",
1537                                               source, master->name);
1538                                 } else {
1539                                         master->name = name;
1540 -                                       debug(LOGOPT_NONE,
1541 -                                             "reading master %s %s",
1542 +                                       debug(logopt, "reading master %s %s",
1543                                               source, tmp + 1);
1544                                 }
1545
1546 @@ -208,7 +206,7 @@ int lookup_nss_read_master(struct master *master, time_t age)
1547         if (result) {
1548                 if (!list_empty(&nsslist))
1549                         free_sources(&nsslist);
1550 -               error(LOGOPT_ANY, "can't to read name service switch config.");
1551 +               error(logopt, "can't to read name service switch config.");
1552                 return 0;
1553         }
1554
1555 @@ -220,13 +218,12 @@ int lookup_nss_read_master(struct master *master, time_t age)
1556
1557                 this = list_entry(p, struct nss_source, list);
1558
1559 -               debug(LOGOPT_NONE,
1560 +               debug(logopt,
1561                       "reading master %s %s", this->source, master->name);
1562
1563                 result = read_master_map(master, this->source, age);
1564                 if (result == NSS_STATUS_UNKNOWN) {
1565 -                       debug(LOGOPT_NONE,
1566 -                             "no map - continuing to next source");
1567 +                       debug(logopt, "no map - continuing to next source");
1568                         continue;
1569                 }
1570
1571 @@ -1008,9 +1005,10 @@ int lookup_prune_cache(struct autofs_point *ap, time_t age)
1572                                 if (this->ioctlfd == -1)
1573                                         status = cache_delete(mc, key);
1574                                 if (status != CHE_FAIL) {
1575 -                                       if (ap->type == LKP_INDIRECT)
1576 -                                               rmdir_path(ap, path, ap->dev);
1577 -                                       else
1578 +                                       if (ap->type == LKP_INDIRECT) {
1579 +                                               if (ap->ghost)
1580 +                                                       rmdir_path(ap, path, ap->dev);
1581 +                                       } else
1582                                                 rmdir_path(ap, path, this->dev);
1583                                 }
1584                         }
1585 diff --git a/daemon/module.c b/daemon/module.c
1586 index e83c929..36eca00 100644
1587 --- a/daemon/module.c
1588 +++ b/daemon/module.c
1589 @@ -33,7 +33,7 @@ int load_autofs4_module(void)
1590          */
1591         fp = fopen("/proc/filesystems", "r");
1592         if (!fp) {
1593 -               error(LOGOPT_ANY, "cannot open /proc/filesystems\n");
1594 +               logerr("cannot open /proc/filesystems\n");
1595                 return 0;
1596         }
1597
1598 @@ -45,7 +45,7 @@ int load_autofs4_module(void)
1599         }
1600         fclose(fp);
1601
1602 -       ret = spawnl(log_debug, PATH_MODPROBE, PATH_MODPROBE,
1603 +       ret = spawnl(LOGOPT_NONE, PATH_MODPROBE, PATH_MODPROBE,
1604                                 "-q", FS_MODULE_NAME, NULL);
1605         if (ret)
1606                 return 0;
1607 @@ -72,7 +72,7 @@ struct lookup_mod *open_lookup(const char *name, const char *err_prefix,
1608         if (!mod) {
1609                 if (err_prefix) {
1610                         char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1611 -                       crit(LOGOPT_ANY, "%s%s", err_prefix, estr);
1612 +                       logerr("%s%s", err_prefix, estr);
1613                 }
1614                 return NULL;
1615         }
1616 @@ -83,7 +83,7 @@ struct lookup_mod *open_lookup(const char *name, const char *err_prefix,
1617                 free(mod);
1618                 if (err_prefix) {
1619                         char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1620 -                       crit(LOGOPT_ANY, "%s%s", err_prefix, estr);
1621 +                       logerr("%s%s", err_prefix, estr);
1622                 }
1623                 return NULL;
1624         }
1625 @@ -91,7 +91,7 @@ struct lookup_mod *open_lookup(const char *name, const char *err_prefix,
1626
1627         if (!(dh = dlopen(fnbuf, RTLD_NOW))) {
1628                 if (err_prefix)
1629 -                       crit(LOGOPT_ANY, "%scannot open lookup module %s (%s)",
1630 +                       logerr("%scannot open lookup module %s (%s)",
1631                                err_prefix, name, dlerror());
1632                 free(mod);
1633                 return NULL;
1634 @@ -100,8 +100,7 @@ struct lookup_mod *open_lookup(const char *name, const char *err_prefix,
1635         if (!(ver = (int *) dlsym(dh, "lookup_version"))
1636             || *ver != AUTOFS_LOOKUP_VERSION) {
1637                 if (err_prefix)
1638 -                       crit(LOGOPT_ANY,
1639 -                            "%slookup module %s version mismatch",
1640 +                       logerr("%slookup module %s version mismatch",
1641                              err_prefix, name);
1642                 dlclose(dh);
1643                 free(mod);
1644 @@ -114,7 +113,7 @@ struct lookup_mod *open_lookup(const char *name, const char *err_prefix,
1645             !(mod->lookup_mount = (lookup_mount_t) dlsym(dh, "lookup_mount")) ||
1646             !(mod->lookup_done = (lookup_done_t) dlsym(dh, "lookup_done"))) {
1647                 if (err_prefix)
1648 -                       crit(LOGOPT_ANY, "%slookup module %s corrupt", err_prefix, name);
1649 +                       logerr("%slookup module %s corrupt", err_prefix, name);
1650                 dlclose(dh);
1651                 free(mod);
1652                 return NULL;
1653 @@ -156,7 +155,7 @@ struct parse_mod *open_parse(const char *name, const char *err_prefix,
1654         if (!mod) {
1655                 if (err_prefix) {
1656                         char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1657 -                       crit(LOGOPT_ANY, "%s%s", err_prefix, estr);
1658 +                       logerr("%s%s", err_prefix, estr);
1659                 }
1660                 return NULL;
1661         }
1662 @@ -167,7 +166,7 @@ struct parse_mod *open_parse(const char *name, const char *err_prefix,
1663                 free(mod);
1664                 if (err_prefix) {
1665                         char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1666 -                       crit(LOGOPT_ANY, "%s%s", err_prefix, estr);
1667 +                       logerr("%s%s", err_prefix, estr);
1668                 }
1669                 return NULL;
1670         }
1671 @@ -175,8 +174,7 @@ struct parse_mod *open_parse(const char *name, const char *err_prefix,
1672
1673         if (!(dh = dlopen(fnbuf, RTLD_NOW))) {
1674                 if (err_prefix)
1675 -                       crit(LOGOPT_ANY,
1676 -                            "%scannot open parse module %s (%s)",
1677 +                       logerr("%scannot open parse module %s (%s)",
1678                              err_prefix, name, dlerror());
1679                 free(mod);
1680                 return NULL;
1681 @@ -185,8 +183,7 @@ struct parse_mod *open_parse(const char *name, const char *err_prefix,
1682         if (!(ver = (int *) dlsym(dh, "parse_version"))
1683             || *ver != AUTOFS_PARSE_VERSION) {
1684                 if (err_prefix)
1685 -                       crit(LOGOPT_ANY,
1686 -                            "%sparse module %s version mismatch",
1687 +                       logerr("%sparse module %s version mismatch",
1688                              err_prefix, name);
1689                 dlclose(dh);
1690                 free(mod);
1691 @@ -197,8 +194,7 @@ struct parse_mod *open_parse(const char *name, const char *err_prefix,
1692             !(mod->parse_mount = (parse_mount_t) dlsym(dh, "parse_mount")) ||
1693             !(mod->parse_done = (parse_done_t) dlsym(dh, "parse_done"))) {
1694                 if (err_prefix)
1695 -                       crit(LOGOPT_ANY,
1696 -                            "%sparse module %s corrupt",
1697 +                       logerr("%sparse module %s corrupt",
1698                              err_prefix, name);
1699                 dlclose(dh);
1700                 free(mod);
1701 @@ -240,7 +236,7 @@ struct mount_mod *open_mount(const char *name, const char *err_prefix)
1702         if (!mod) {
1703                 if (err_prefix) {
1704                         char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1705 -                       crit(LOGOPT_ANY, "%s%s", err_prefix, estr);
1706 +                       logerr("%s%s", err_prefix, estr);
1707                 }
1708                 return NULL;
1709         }
1710 @@ -251,7 +247,7 @@ struct mount_mod *open_mount(const char *name, const char *err_prefix)
1711                 free(mod);
1712                 if (err_prefix) {
1713                         char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1714 -                       crit(LOGOPT_ANY, "%s%s", err_prefix, estr);
1715 +                       logerr("%s%s", err_prefix, estr);
1716                 }
1717                 return NULL;
1718         }
1719 @@ -259,8 +255,7 @@ struct mount_mod *open_mount(const char *name, const char *err_prefix)
1720
1721         if (!(dh = dlopen(fnbuf, RTLD_NOW))) {
1722                 if (err_prefix)
1723 -                       crit(LOGOPT_ANY,
1724 -                            "%scannot open mount module %s (%s)",
1725 +                       logerr("%scannot open mount module %s (%s)",
1726                              err_prefix, name, dlerror());
1727                 free(mod);
1728                 return NULL;
1729 @@ -269,8 +264,7 @@ struct mount_mod *open_mount(const char *name, const char *err_prefix)
1730         if (!(ver = (int *) dlsym(dh, "mount_version"))
1731             || *ver != AUTOFS_MOUNT_VERSION) {
1732                 if (err_prefix)
1733 -                       crit(LOGOPT_ANY,
1734 -                            "%smount module %s version mismatch",
1735 +                       logerr("%smount module %s version mismatch",
1736                              err_prefix, name);
1737                 dlclose(dh);
1738                 free(mod);
1739 @@ -281,8 +275,7 @@ struct mount_mod *open_mount(const char *name, const char *err_prefix)
1740             !(mod->mount_mount = (mount_mount_t) dlsym(dh, "mount_mount")) ||
1741             !(mod->mount_done = (mount_done_t) dlsym(dh, "mount_done"))) {
1742                 if (err_prefix)
1743 -                       crit(LOGOPT_ANY,
1744 -                            "%smount module %s corrupt",
1745 +                       logerr("%smount module %s corrupt",
1746                              err_prefix, name);
1747                 dlclose(dh);
1748                 free(mod);
1749 diff --git a/daemon/spawn.c b/daemon/spawn.c
1750 index 271d37e..3d5ea56 100644
1751 --- a/daemon/spawn.c
1752 +++ b/daemon/spawn.c
1753 @@ -88,7 +88,7 @@ void reset_signals(void)
1754
1755  #define ERRBUFSIZ 2047         /* Max length of error string excl \0 */
1756
1757 -static int do_spawn(logger *log, unsigned int options, const char *prog, const char *const *argv)
1758 +static int do_spawn(unsigned logopt, unsigned int options, const char *prog, const char *const *argv)
1759  {
1760         pid_t f;
1761         int ret, status, pipefd[2];
1762 @@ -195,7 +195,7 @@ static int do_spawn(logger *log, unsigned int options, const char *prog, const c
1763                                 while (errp && (p = memchr(sp, '\n', errp))) {
1764                                         *p++ = '\0';
1765                                         if (sp[0])      /* Don't output empty lines */
1766 -                                               log(LOGOPT_ANY, ">> %s", sp);
1767 +                                               warn(logopt, ">> %s", sp);
1768                                         errp -= (p - sp);
1769                                         sp = p;
1770                                 }
1771 @@ -206,7 +206,7 @@ static int do_spawn(logger *log, unsigned int options, const char *prog, const c
1772                                 if (errp >= ERRBUFSIZ) {
1773                                         /* Line too long, split */
1774                                         errbuf[errp] = '\0';
1775 -                                       log(LOGOPT_ANY, ">> %s", errbuf);
1776 +                                       warn(logopt, ">> %s", errbuf);
1777                                         errp = 0;
1778                                 }
1779                         }
1780 @@ -217,7 +217,7 @@ static int do_spawn(logger *log, unsigned int options, const char *prog, const c
1781                 if (errp > 0) {
1782                         /* End of file without \n */
1783                         errbuf[errp] = '\0';
1784 -                       log(LOGOPT_ANY, ">> %s", errbuf);
1785 +                       warn(logopt, ">> %s", errbuf);
1786                 }
1787
1788                 if (waitpid(f, &ret, 0) != f)
1789 @@ -235,12 +235,12 @@ static int do_spawn(logger *log, unsigned int options, const char *prog, const c
1790         }
1791  }
1792
1793 -int spawnv(logger *log, const char *prog, const char *const *argv)
1794 +int spawnv(unsigned logopt, const char *prog, const char *const *argv)
1795  {
1796 -       return do_spawn(log, SPAWN_OPT_NONE, prog, argv);
1797 +       return do_spawn(logopt, SPAWN_OPT_NONE, prog, argv);
1798  }
1799
1800 -int spawnl(logger *log, const char *prog, ...)
1801 +int spawnl(unsigned logopt, const char *prog, ...)
1802  {
1803         va_list arg;
1804         int argc;
1805 @@ -258,10 +258,10 @@ int spawnl(logger *log, const char *prog, ...)
1806         while ((*p++ = va_arg(arg, char *)));
1807         va_end(arg);
1808
1809 -       return do_spawn(log, SPAWN_OPT_NONE, prog, (const char **) argv);
1810 +       return do_spawn(logopt, SPAWN_OPT_NONE, prog, (const char **) argv);
1811  }
1812
1813 -int spawn_mount(logger *log, ...)
1814 +int spawn_mount(unsigned logopt, ...)
1815  {
1816         va_list arg;
1817         int argc;
1818 @@ -279,7 +279,7 @@ int spawn_mount(logger *log, ...)
1819         options = SPAWN_OPT_NONE;
1820  #endif
1821
1822 -       va_start(arg, log);
1823 +       va_start(arg, logopt);
1824         for (argc = 1; va_arg(arg, char *); argc++);
1825         va_end(arg);
1826
1827 @@ -288,13 +288,13 @@ int spawn_mount(logger *log, ...)
1828
1829         argv[0] = arg0;
1830
1831 -       va_start(arg, log);
1832 +       va_start(arg, logopt);
1833         p = argv + 1;
1834         while ((*p++ = va_arg(arg, char *)));
1835         va_end(arg);
1836
1837         while (retries--) {
1838 -               ret = do_spawn(log, options, prog, (const char **) argv);
1839 +               ret = do_spawn(logopt, options, prog, (const char **) argv);
1840                 if (ret & MTAB_NOTUPDATED)
1841                         continue;
1842                 break;
1843 @@ -311,7 +311,7 @@ int spawn_mount(logger *log, ...)
1844   * NOTE: If mount locking is enabled this type of recursive mount cannot
1845   *      work.
1846   */
1847 -int spawn_bind_mount(logger *log, ...)
1848 +int spawn_bind_mount(unsigned logopt, ...)
1849  {
1850         va_list arg;
1851         int argc;
1852 @@ -330,7 +330,7 @@ int spawn_bind_mount(logger *log, ...)
1853         options = SPAWN_OPT_ACCESS;
1854  #endif
1855
1856 -       va_start(arg, log);
1857 +       va_start(arg, logopt);
1858         for (argc = 1; va_arg(arg, char *); argc++);
1859         va_end(arg);
1860
1861 @@ -340,13 +340,13 @@ int spawn_bind_mount(logger *log, ...)
1862         argv[0] = arg0;
1863         argv[1] = bind;
1864
1865 -       va_start(arg, log);
1866 +       va_start(arg, logopt);
1867         p = argv + 2;
1868         while ((*p++ = va_arg(arg, char *)));
1869         va_end(arg);
1870
1871         while (retries--) {
1872 -               ret = do_spawn(log, options, prog, (const char **) argv);
1873 +               ret = do_spawn(logopt, options, prog, (const char **) argv);
1874                 if (ret & MTAB_NOTUPDATED)
1875                         continue;
1876                 break;
1877 @@ -355,7 +355,7 @@ int spawn_bind_mount(logger *log, ...)
1878         return ret;
1879  }
1880
1881 -int spawn_umount(logger *log, ...)
1882 +int spawn_umount(unsigned logopt, ...)
1883  {
1884         va_list arg;
1885         int argc;
1886 @@ -372,7 +372,7 @@ int spawn_umount(logger *log, ...)
1887         options = SPAWN_OPT_NONE;
1888  #endif
1889
1890 -       va_start(arg, log);
1891 +       va_start(arg, logopt);
1892         for (argc = 1; va_arg(arg, char *); argc++);
1893         va_end(arg);
1894
1895 @@ -381,13 +381,13 @@ int spawn_umount(logger *log, ...)
1896
1897         argv[0] = arg0;
1898
1899 -       va_start(arg, log);
1900 +       va_start(arg, logopt);
1901         p = argv + 1;
1902         while ((*p++ = va_arg(arg, char *)));
1903         va_end(arg);
1904
1905         while (retries--) {
1906 -               ret = do_spawn(log, options, prog, (const char **) argv);
1907 +               ret = do_spawn(logopt, options, prog, (const char **) argv);
1908                 if (ret & MTAB_NOTUPDATED)
1909                         continue;
1910                 break;
1911 diff --git a/daemon/state.c b/daemon/state.c
1912 index 39f4497..a2da762 100644
1913 --- a/daemon/state.c
1914 +++ b/daemon/state.c
1915 @@ -58,22 +58,20 @@ void dump_state_queue(void)
1916         struct list_head *head = &state_queue;
1917         struct list_head *p, *q;
1918
1919 -       debug(LOGOPT_ANY, "dumping queue");
1920 +       logmsg("dumping queue");
1921
1922         list_for_each(p, head) {
1923                 struct state_queue *entry;
1924
1925                 entry = list_entry(p, struct state_queue, list);
1926 -               debug(LOGOPT_ANY,
1927 -                     "queue list head path %s state %d busy %d",
1928 +               logmsg("queue list head path %s state %d busy %d",
1929                       entry->ap->path, entry->state, entry->busy);
1930
1931                 list_for_each(q, &entry->pending) {
1932                         struct state_queue *this;
1933
1934                         this = list_entry(q, struct state_queue, pending);
1935 -                       debug(LOGOPT_ANY,
1936 -                             "queue list entry path %s state %d busy %d",
1937 +                       logmsg("queue list entry path %s state %d busy %d",
1938                               this->ap->path, this->state, this->busy);
1939                 }
1940         }
1941 @@ -85,7 +83,7 @@ void nextstate(int statefd, enum states next)
1942
1943         if (write(statefd, &next, sizeof(next)) != sizeof(next)) {
1944                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1945 -               error(LOGOPT_ANY, "write failed %s", estr);
1946 +               logerr("write failed %s", estr);
1947         }
1948  }
1949
1950 diff --git a/include/automount.h b/include/automount.h
1951 index d55ba5c..37a3c0a 100644
1952 --- a/include/automount.h
1953 +++ b/include/automount.h
1954 @@ -131,6 +131,7 @@ struct mapent_cache {
1955         unsigned int size;
1956         pthread_mutex_t ino_index_mutex;
1957         struct list_head *ino_index;
1958 +       struct autofs_point *ap;
1959         struct map_source *map;
1960         struct mapent **hash;
1961  };
1962 @@ -164,7 +165,7 @@ void cache_readlock(struct mapent_cache *mc);
1963  void cache_writelock(struct mapent_cache *mc);
1964  int cache_try_writelock(struct mapent_cache *mc);
1965  void cache_unlock(struct mapent_cache *mc);
1966 -struct mapent_cache *cache_init(struct map_source *map);
1967 +struct mapent_cache *cache_init(struct autofs_point *ap, struct map_source *map);
1968  struct mapent_cache *cache_init_null_cache(struct master *master);
1969  int cache_set_ino_index(struct mapent_cache *mc, const char *key, dev_t dev, ino_t ino);
1970  /* void cache_set_ino(struct mapent *me, dev_t dev, ino_t ino); */
1971 @@ -200,11 +201,11 @@ int free_argv(int argc, const char **argv);
1972  inline void dump_core(void);
1973  int aquire_lock(void);
1974  void release_lock(void);
1975 -int spawnl(logger *log, const char *prog, ...);
1976 -int spawnv(logger *log, const char *prog, const char *const *argv);
1977 -int spawn_mount(logger *log, ...);
1978 -int spawn_bind_mount(logger *log, ...);
1979 -int spawn_umount(logger *log, ...);
1980 +int spawnl(unsigned logopt, const char *prog, ...);
1981 +int spawnv(unsigned logopt, const char *prog, const char *const *argv);
1982 +int spawn_mount(unsigned logopt, ...);
1983 +int spawn_bind_mount(unsigned logopt, ...);
1984 +int spawn_umount(unsigned logopt, ...);
1985  void reset_signals(void);
1986  int do_mount(struct autofs_point *ap, const char *root, const char *name,
1987              int name_len, const char *what, const char *fstype,
1988 @@ -222,6 +223,8 @@ int rmdir_path(struct autofs_point *ap, const char *path, dev_t dev);
1989  #define MAPENT_MAX_LEN 4095
1990  #define PARSE_MAX_BUF  KEY_MAX_LEN + MAPENT_MAX_LEN + 2
1991
1992 +#define AUTOFS_LOGPRI_FIFO "/tmp/autofs.fifo"
1993 +
1994  int lookup_nss_read_master(struct master *master, time_t age);
1995  int lookup_nss_read_map(struct autofs_point *ap, struct map_source *source, time_t age);
1996  int lookup_enumerate(struct autofs_point *ap,
1997 @@ -435,6 +438,7 @@ struct autofs_point {
1998         int pipefd;                     /* File descriptor for pipe */
1999         int kpipefd;                    /* Kernel end descriptor for pipe */
2000         int ioctlfd;                    /* File descriptor for ioctls */
2001 +       int logpri_fifo;                /* FIFO used for changing log levels */
2002         dev_t dev;                      /* "Device" number assigned by kernel */
2003         struct master_mapent *entry;    /* Master map entry for this mount */
2004         unsigned int type;              /* Type of map direct or indirect */
2005 @@ -464,8 +468,8 @@ struct autofs_point {
2006
2007  void *handle_mounts(void *arg);
2008  int umount_multi(struct autofs_point *ap, const char *path, int incl);
2009 -int send_ready(int ioctlfd, unsigned int wait_queue_token);
2010 -int send_fail(int ioctlfd, unsigned int wait_queue_token);
2011 +int send_ready(unsigned logopt, int ioctlfd, unsigned int wait_queue_token);
2012 +int send_fail(unsigned logopt, int ioctlfd, unsigned int wait_queue_token);
2013  int do_expire(struct autofs_point *ap, const char *name, int namelen);
2014  void *expire_proc_indirect(void *);
2015  void *expire_proc_direct(void *);
2016 @@ -483,8 +487,8 @@ int handle_packet_expire_indirect(struct autofs_point *ap, autofs_packet_expire_
2017  int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_direct_t *pkt);
2018  int handle_packet_missing_indirect(struct autofs_point *ap, autofs_packet_missing_indirect_t *pkt);
2019  int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_direct_t *pkt);
2020 -void rm_unwanted(const char *path, int incl, dev_t dev);
2021 -int count_mounts(const char *path, dev_t dev);
2022 +void rm_unwanted(unsigned logopt, const char *path, int incl, dev_t dev);
2023 +int count_mounts(unsigned logopt, const char *path, dev_t dev);
2024
2025  #define state_mutex_lock(ap) \
2026  do { \
2027 diff --git a/include/log.h b/include/log.h
2028 index 3276cca..6a4a942 100644
2029 --- a/include/log.h
2030 +++ b/include/log.h
2031 @@ -20,6 +20,7 @@
2032  /* Define logging functions */
2033
2034  #define LOGOPT_NONE    0x0000
2035 +#define LOGOPT_ERROR   0x0000
2036  #define LOGOPT_DEBUG   0x0001
2037  #define LOGOPT_VERBOSE 0x0002
2038  #define LOGOPT_ANY     (LOGOPT_DEBUG | LOGOPT_VERBOSE)
2039 @@ -29,34 +30,33 @@ struct autofs_point;
2040  extern void set_log_norm(void);
2041  extern void set_log_verbose(void);
2042  extern void set_log_debug(void);
2043 -extern void set_mnt_logging(struct autofs_point *);
2044 +extern void set_log_norm_ap(struct autofs_point *ap);
2045 +extern void set_log_verbose_ap(struct autofs_point *ap);
2046 +extern void set_log_debug_ap(struct autofs_point *ap);
2047 +extern void set_mnt_logging(unsigned global_logopt);
2048
2049  extern void log_to_syslog(void);
2050  extern void log_to_stderr(void);
2051
2052 -typedef void logger(unsigned int logopt, const char* msg, ...);
2053 -
2054 -extern void (*log_info)(unsigned int, const char* msg, ...);
2055 -extern void (*log_notice)(unsigned int, const char* msg, ...);
2056 -extern void (*log_warn)(unsigned int, const char* msg, ...);
2057 -extern void (*log_error)(unsigned int, const char* msg, ...);
2058 -extern void (*log_crit)(unsigned int, const char* msg, ...);
2059 -extern void (*log_debug)(unsigned int, const char* msg, ...);
2060 -
2061 -#define msg(msg, args...)      \
2062 -       do { log_info(LOGOPT_NONE, msg, ##args); } while (0)
2063 +extern void log_info(unsigned int, const char* msg, ...);
2064 +extern void log_notice(unsigned int, const char* msg, ...);
2065 +extern void log_warn(unsigned int, const char* msg, ...);
2066 +extern void log_error(unsigned, const char* msg, ...);
2067 +extern void log_crit(unsigned, const char* msg, ...);
2068 +extern void log_debug(unsigned int, const char* msg, ...);
2069 +extern void logmsg(const char* msg, ...);
2070
2071  #define debug(opt, msg, args...)       \
2072         do { log_debug(opt, "%s: " msg,  __FUNCTION__, ##args); } while (0)
2073
2074 -#define info(opt, msg, args...)        \
2075 -       do { log_info(opt, "%s: " msg,  __FUNCTION__, ##args); } while (0)
2076 +#define info(opt, msg, args...)                \
2077 +       do { log_info(opt, msg,  ##args); } while (0)
2078
2079  #define notice(opt, msg, args...)      \
2080 -       do { log_notice(opt, "%s: " msg,  __FUNCTION__, ##args); } while (0)
2081 +       do { log_notice(opt, msg, ##args); } while (0)
2082
2083 -#define warn(opt, msg, args...)        \
2084 -       do { log_warn(opt, "%s: " msg,  __FUNCTION__, ##args); } while (0)
2085 +#define warn(opt, msg, args...)                \
2086 +       do { log_warn(opt, msg, ##args); } while (0)
2087
2088  #define error(opt, msg, args...)       \
2089         do { log_error(opt, "%s: " msg,  __FUNCTION__, ##args); } while (0)
2090 @@ -64,17 +64,18 @@ extern void (*log_debug)(unsigned int, const char* msg, ...);
2091  #define crit(opt, msg, args...)        \
2092         do { log_crit(opt, "%s: " msg,  __FUNCTION__, ##args); } while (0)
2093
2094 +#define logerr(msg, args...)   \
2095 +       do { logmsg("%s:%d: " msg, __FUNCTION__, __LINE__, ##args); } while (0)
2096 +
2097  #define fatal(status)                                              \
2098         do {                                                        \
2099                 if (status == EDEADLK) {                            \
2100 -                       log_crit(LOGOPT_ANY,                        \
2101 -                                "%s: deadlock detected "           \
2102 +                       logmsg("deadlock detected "                 \
2103                                  "at line %d in %s, dumping core.", \
2104 -                                __FUNCTION__, __LINE__, __FILE__); \
2105 +                                 __LINE__, __FILE__);              \
2106                         dump_core();                                \
2107                 }                                                   \
2108 -               log_crit(LOGOPT_ANY,                                \
2109 -                        "unexpected pthreads error: %d at %d "     \
2110 +               logmsg("unexpected pthreads error: %d at %d "       \
2111                          "in %s", status, __LINE__, __FILE__);      \
2112                 abort();                                            \
2113         } while(0)
2114 @@ -83,7 +84,7 @@ extern void (*log_debug)(unsigned int, const char* msg, ...);
2115  #define assert(x)                                                      \
2116  do {                                                                   \
2117         if (!(x)) {                                                     \
2118 -               log_crit(LOGOPT_ANY, __FILE__                           \
2119 +               logmsg(__FILE__                                 \
2120                          ":%d: assertion failed: " #x, __LINE__);       \
2121         }                                                               \
2122  } while(0)
2123 diff --git a/include/lookup_ldap.h b/include/lookup_ldap.h
2124 index ca8d658..5b5c475 100644
2125 --- a/include/lookup_ldap.h
2126 +++ b/include/lookup_ldap.h
2127 @@ -94,13 +94,13 @@ struct lookup_context {
2128  #define LDAP_AUTH_AUTODETECT   0x0004
2129
2130  /* lookup_ldap.c */
2131 -LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt);
2132 -int unbind_ldap_connection(LDAP *ldap, struct lookup_context *ctxt);
2133 +LDAP *init_ldap_connection(unsigned logopt, const char *uri, struct lookup_context *ctxt);
2134 +int unbind_ldap_connection(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt);
2135  int authtype_requires_creds(const char *authtype);
2136
2137  /* cyrus-sasl.c */
2138 -int autofs_sasl_init(LDAP *ldap, struct lookup_context *ctxt);
2139 -int autofs_sasl_bind(LDAP *ldap, struct lookup_context *ctxt);
2140 +int autofs_sasl_init(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt);
2141 +int autofs_sasl_bind(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt);
2142  void autofs_sasl_unbind(struct lookup_context *ctxt);
2143  void autofs_sasl_done(struct lookup_context *ctxt);
2144  #endif
2145 diff --git a/include/master.h b/include/master.h
2146 index 8470bb1..5f10d1f 100644
2147 --- a/include/master.h
2148 +++ b/include/master.h
2149 @@ -62,6 +62,7 @@ struct master {
2150         unsigned int default_ghost;
2151         unsigned int default_logging;
2152         unsigned int default_timeout;
2153 +       unsigned int logopt;
2154         struct mapent_cache *nc;
2155         struct list_head mounts;
2156  };
2157 @@ -106,6 +107,7 @@ int master_notify_submount(struct autofs_point *, const char *path, enum states)
2158  void master_signal_submount(struct autofs_point *, unsigned int);
2159  void master_notify_state_change(struct master *, int);
2160  int master_mount_mounts(struct master *, time_t, int);
2161 +extern inline unsigned int master_get_logopt(void);
2162  int master_list_empty(struct master *);
2163  int master_kill(struct master *);
2164
2165 diff --git a/include/replicated.h b/include/replicated.h
2166 index 3afe9f7..672f853 100644
2167 --- a/include/replicated.h
2168 +++ b/include/replicated.h
2169 @@ -62,8 +62,8 @@ struct host {
2170
2171  void seed_random(void);
2172  void free_host_list(struct host **);
2173 -int parse_location(struct host **, const char *);
2174 -int prune_host_list(struct host **, unsigned int, const char *, unsigned int);
2175 +int parse_location(unsigned, struct host **, const char *);
2176 +int prune_host_list(unsigned, struct host **, unsigned int, const char *, unsigned int);
2177  void dump_host_list(struct host *);
2178
2179  #endif
2180 diff --git a/lib/alarm.c b/lib/alarm.c
2181 index 90bf7aa..6a70ed1 100755
2182 --- a/lib/alarm.c
2183 +++ b/lib/alarm.c
2184 @@ -51,7 +51,7 @@ void dump_alarms(void)
2185                 struct alarm *this;
2186
2187                 this = list_entry(p, struct alarm, list);
2188 -               msg("alarm time = %d", this->time);
2189 +               logmsg("alarm time = %d", this->time);
2190         }
2191         pthread_mutex_unlock(&mutex);
2192  }
2193 diff --git a/lib/args.c b/lib/args.c
2194 index fbfb004..9616598 100644
2195 --- a/lib/args.c
2196 +++ b/lib/args.c
2197 @@ -37,7 +37,7 @@ char **add_argv(int argc, char **argv, char *str)
2198                 if (argv[i]) {
2199                         vector[i] = strdup(argv[i]);
2200                         if (!vector[i]) {
2201 -                               error(LOGOPT_ANY, "failed to strdup arg");
2202 +                               logerr("failed to strdup arg");
2203                                 break;
2204                         }
2205                 } else
2206 @@ -81,7 +81,7 @@ char **append_argv(int argc1, char **argv1, int argc2, char **argv2)
2207                 if (argv2[j]) {
2208                         vector[i] = strdup(argv2[j]);
2209                         if (!vector[i]) {
2210 -                               error(LOGOPT_ANY, "failed to strdup arg");
2211 +                               logerr("failed to strdup arg");
2212                                 break;
2213                         }
2214                 } else
2215 @@ -116,7 +116,7 @@ const char **copy_argv(int argc, const char **argv)
2216                 if (argv[i]) {
2217                         vector[i] = strdup(argv[i]);
2218                         if (!vector[i]) {
2219 -                               error(LOGOPT_ANY, "failed to strdup arg");
2220 +                               logerr("failed to strdup arg");
2221                                 break;
2222                         }
2223                 } else
2224 diff --git a/lib/cache.c b/lib/cache.c
2225 index 06bb461..55586a3 100644
2226 --- a/lib/cache.c
2227 +++ b/lib/cache.c
2228 @@ -34,7 +34,7 @@ void cache_dump_multi(struct list_head *list)
2229
2230         list_for_each(p, list) {
2231                 me = list_entry(p, struct mapent, multi_list);
2232 -               msg("key=%s", me->key);
2233 +               logmsg("key=%s", me->key);
2234         }
2235  }
2236
2237 @@ -48,7 +48,7 @@ void cache_dump_cache(struct mapent_cache *mc)
2238                 if (me == NULL)
2239                         continue;
2240                 while (me) {
2241 -                       msg("me->key=%s me->multi=%p dev=%ld ino=%ld",
2242 +                       logmsg("me->key=%s me->multi=%p dev=%ld ino=%ld",
2243                                 me->key, me->multi, me->dev, me->ino);
2244                         me = me->next;
2245                 }
2246 @@ -61,7 +61,7 @@ void cache_readlock(struct mapent_cache *mc)
2247
2248         status = pthread_rwlock_rdlock(&mc->rwlock);
2249         if (status) {
2250 -               error(LOGOPT_ANY, "mapent cache rwlock lock failed");
2251 +               logmsg("mapent cache rwlock lock failed");
2252                 fatal(status);
2253         }
2254         return;
2255 @@ -73,7 +73,7 @@ void cache_writelock(struct mapent_cache *mc)
2256
2257         status = pthread_rwlock_wrlock(&mc->rwlock);
2258         if (status) {
2259 -               error(LOGOPT_ANY, "mapent cache rwlock lock failed");
2260 +               logmsg("mapent cache rwlock lock failed");
2261                 fatal(status);
2262         }
2263         return;
2264 @@ -85,7 +85,7 @@ int cache_try_writelock(struct mapent_cache *mc)
2265
2266         status = pthread_rwlock_trywrlock(&mc->rwlock);
2267         if (status) {
2268 -               debug(LOGOPT_ANY, "mapent cache rwlock busy");
2269 +               logmsg("mapent cache rwlock busy");
2270                 return 0;
2271         }
2272         return 1;
2273 @@ -97,7 +97,7 @@ void cache_unlock(struct mapent_cache *mc)
2274
2275         status = pthread_rwlock_unlock(&mc->rwlock);
2276         if (status) {
2277 -               error(LOGOPT_ANY, "mapent cache rwlock unlock failed");
2278 +               logmsg("mapent cache rwlock unlock failed");
2279                 fatal(status);
2280         }
2281         return;
2282 @@ -120,7 +120,7 @@ void cache_multi_lock(struct mapent *me)
2283
2284         status = pthread_mutex_lock(&me->multi_mutex);
2285         if (status) {
2286 -               error(LOGOPT_ANY, "mapent cache multi mutex lock failed");
2287 +               logmsg("mapent cache multi mutex lock failed");
2288                 fatal(status);
2289         }
2290         return;
2291 @@ -135,7 +135,7 @@ void cache_multi_unlock(struct mapent *me)
2292
2293         status = pthread_mutex_unlock(&me->multi_mutex);
2294         if (status) {
2295 -               error(LOGOPT_ANY, "mapent cache multi mutex unlock failed");
2296 +               logmsg("mapent cache multi mutex unlock failed");
2297                 fatal(status);
2298         }
2299         return;
2300 @@ -164,7 +164,7 @@ static inline void ino_index_unlock(struct mapent_cache *mc)
2301         return;
2302  }
2303
2304 -struct mapent_cache *cache_init(struct map_source *map)
2305 +struct mapent_cache *cache_init(struct autofs_point *ap, struct map_source *map)
2306  {
2307         struct mapent_cache *mc;
2308         unsigned int i;
2309 @@ -207,6 +207,7 @@ struct mapent_cache *cache_init(struct map_source *map)
2310                 INIT_LIST_HEAD(&mc->ino_index[i]);
2311         }
2312
2313 +       mc->ap = ap;
2314         mc->map = map;
2315
2316         cache_unlock(mc);
2317 @@ -257,6 +258,9 @@ struct mapent_cache *cache_init_null_cache(struct master *master)
2318                 INIT_LIST_HEAD(&mc->ino_index[i]);
2319         }
2320
2321 +       mc->ap = NULL;
2322 +       mc->map = NULL;
2323 +
2324         cache_unlock(mc);
2325
2326         return mc;
2327 @@ -608,6 +612,7 @@ static void cache_add_ordered_offset(struct mapent *me, struct list_head *head)
2328  /* cache must be write locked by caller */
2329  int cache_add_offset(struct mapent_cache *mc, const char *mkey, const char *key, const char *mapent, time_t age)
2330  {
2331 +       unsigned logopt = mc->ap ? mc->ap->logopt : master_get_logopt();
2332         struct mapent *me, *owner;
2333         int ret = CHE_OK;
2334
2335 @@ -621,7 +626,7 @@ int cache_add_offset(struct mapent_cache *mc, const char *mkey, const char *key,
2336
2337         ret = cache_add(mc, owner->source, key, mapent, age);
2338         if (ret == CHE_FAIL) {
2339 -               warn(LOGOPT_ANY, "failed to add key %s to cache", key);
2340 +               warn(logopt, "failed to add key %s to cache", key);
2341                 return CHE_FAIL;
2342         }
2343
2344 @@ -689,6 +694,7 @@ int cache_set_parents(struct mapent *mm)
2345  /* cache must be write locked by caller */
2346  int cache_update(struct mapent_cache *mc, struct map_source *ms, const char *key, const char *mapent, time_t age)
2347  {
2348 +       unsigned logopt = mc->ap ? mc->ap->logopt : master_get_logopt();
2349         struct mapent *me = NULL;
2350         char *pent;
2351         int ret = CHE_OK;
2352 @@ -697,7 +703,7 @@ int cache_update(struct mapent_cache *mc, struct map_source *ms, const char *key
2353         if (!me || (*me->key == '*' && *key != '*')) {
2354                 ret = cache_add(mc, ms, key, mapent, age);
2355                 if (!ret) {
2356 -                       debug(LOGOPT_NONE, "failed for %s", key);
2357 +                       debug(logopt, "failed for %s", key);
2358                         return CHE_FAIL;
2359                 }
2360                 ret = CHE_UPDATED;
2361 @@ -796,6 +802,7 @@ done:
2362  /* cache must be write locked by caller */
2363  int cache_delete_offset_list(struct mapent_cache *mc, const char *key)
2364  {
2365 +       unsigned logopt = mc->ap ? mc->ap->logopt : master_get_logopt();
2366         struct mapent *me;
2367         struct mapent *this;
2368         struct list_head *head, *next;
2369 @@ -816,7 +823,7 @@ int cache_delete_offset_list(struct mapent_cache *mc, const char *key)
2370                 this = list_entry(next, struct mapent, multi_list);
2371                 next = next->next;
2372                 if (this->ioctlfd != -1) {
2373 -                       error(LOGOPT_ANY,
2374 +                       error(logopt,
2375                               "active offset mount key %s", this->key);
2376                         return CHE_FAIL;
2377                 }
2378 @@ -829,10 +836,10 @@ int cache_delete_offset_list(struct mapent_cache *mc, const char *key)
2379                 next = next->next;
2380                 list_del_init(&this->multi_list);
2381                 this->multi = NULL;
2382 -               debug(LOGOPT_NONE, "deleting offset key %s", this->key);
2383 +               debug(logopt, "deleting offset key %s", this->key);
2384                 status = cache_delete(mc, this->key);
2385                 if (status == CHE_FAIL) {
2386 -                       warn(LOGOPT_ANY,
2387 +                       warn(logopt,
2388                              "failed to delete offset %s", this->key);
2389                         this->multi = me;
2390                         /* TODO: add list back in */
2391 diff --git a/lib/defaults.c b/lib/defaults.c
2392 index 2cccf20..94885e8 100644
2393 --- a/lib/defaults.c
2394 +++ b/lib/defaults.c
2395 @@ -105,17 +105,22 @@ static int get_env_yesno(const char *name)
2396   * We've changed the key names so we need to check for the
2397   * config key and it's old name for backward conpatibility.
2398  */
2399 -static int check_set_config_value(const char *res, const char *name, const char *value)
2400 +static int check_set_config_value(const char *res, const char *name, const char *value, unsigned to_syslog)
2401  {
2402         char *old_name;
2403         int ret;
2404
2405         if (!strcasecmp(res, name)) {
2406                 ret = setenv(name, value, 0);
2407 -               if (ret)
2408 -                       fprintf(stderr,
2409 -                               "can't set config value for %s, "
2410 -                               "error %d", name, ret);
2411 +               if (ret) {
2412 +                       if (!to_syslog)
2413 +                               fprintf(stderr,
2414 +                                       "can't set config value for %s, "
2415 +                                       "error %d\n", name, ret);
2416 +                       else
2417 +                               logmsg("can't set config value for %s, "
2418 +                                     "error %d", name, ret);
2419 +               }
2420                 return 1;
2421         }
2422
2423 @@ -125,10 +130,15 @@ static int check_set_config_value(const char *res, const char *name, const char
2424
2425         if (!strcasecmp(res, old_name)) {
2426                 ret = setenv(name, value, 0);
2427 -               if (ret)
2428 -                       fprintf(stderr,
2429 -                               "can't set config value for %s, "
2430 -                               "error %d", name, ret);
2431 +               if (ret) {
2432 +                       if (!to_syslog)
2433 +                               fprintf(stderr,
2434 +                                       "can't set config value for %s, "
2435 +                                       "error %d\n", name, ret);
2436 +                       else
2437 +                               logmsg("can't set config value for %s, "
2438 +                                     "error %d\n", name, ret);
2439 +               }
2440                 return 1;
2441         }
2442         return 0;
2443 @@ -296,19 +306,19 @@ unsigned int defaults_read_config(unsigned int to_syslog)
2444                 if (!parse_line(res, &key, &value))
2445                         continue;
2446
2447 -               if (check_set_config_value(key, ENV_NAME_MASTER_MAP, value) ||
2448 -                   check_set_config_value(key, ENV_NAME_TIMEOUT, value) ||
2449 -                   check_set_config_value(key, ENV_NAME_BROWSE_MODE, value) ||
2450 -                   check_set_config_value(key, ENV_NAME_LOGGING, value) ||
2451 -                   check_set_config_value(key, ENV_LDAP_TIMEOUT, value) ||
2452 -                   check_set_config_value(key, ENV_LDAP_NETWORK_TIMEOUT, value) ||
2453 -                   check_set_config_value(key, ENV_NAME_MAP_OBJ_CLASS, value) ||
2454 -                   check_set_config_value(key, ENV_NAME_ENTRY_OBJ_CLASS, value) ||
2455 -                   check_set_config_value(key, ENV_NAME_MAP_ATTR, value) ||
2456 -                   check_set_config_value(key, ENV_NAME_ENTRY_ATTR, value) ||
2457 -                   check_set_config_value(key, ENV_NAME_VALUE_ATTR, value) ||
2458 -                   check_set_config_value(key, ENV_APPEND_OPTIONS, value) ||
2459 -                   check_set_config_value(key, ENV_AUTH_CONF_FILE, value))
2460 +               if (check_set_config_value(key, ENV_NAME_MASTER_MAP, value, to_syslog) ||
2461 +                   check_set_config_value(key, ENV_NAME_TIMEOUT, value, to_syslog) ||
2462 +                   check_set_config_value(key, ENV_NAME_BROWSE_MODE, value, to_syslog) ||
2463 +                   check_set_config_value(key, ENV_NAME_LOGGING, value, to_syslog) ||
2464 +                   check_set_config_value(key, ENV_LDAP_TIMEOUT, value, to_syslog) ||
2465 +                   check_set_config_value(key, ENV_LDAP_NETWORK_TIMEOUT, value, to_syslog) ||
2466 +                   check_set_config_value(key, ENV_NAME_MAP_OBJ_CLASS, value, to_syslog) ||
2467 +                   check_set_config_value(key, ENV_NAME_ENTRY_OBJ_CLASS, value, to_syslog) ||
2468 +                   check_set_config_value(key, ENV_NAME_MAP_ATTR, value, to_syslog) ||
2469 +                   check_set_config_value(key, ENV_NAME_ENTRY_ATTR, value, to_syslog) ||
2470 +                   check_set_config_value(key, ENV_NAME_VALUE_ATTR, value, to_syslog) ||
2471 +                   check_set_config_value(key, ENV_APPEND_OPTIONS, value, to_syslog) ||
2472 +                   check_set_config_value(key, ENV_AUTH_CONF_FILE, value, to_syslog))
2473                         ;
2474         }
2475
2476 @@ -318,8 +328,7 @@ unsigned int defaults_read_config(unsigned int to_syslog)
2477                                 "fgets returned error %d while reading %s\n",
2478                                 ferror(f), DEFAULTS_CONFIG_FILE);
2479                 } else {
2480 -                       error(LOGOPT_ANY,
2481 -                             "fgets returned error %d while reading %s",
2482 +                       logmsg("fgets returned error %d while reading %s",
2483                               ferror(f), DEFAULTS_CONFIG_FILE);
2484                 }
2485                 fclose(f);
2486 diff --git a/lib/log.c b/lib/log.c
2487 index b747e12..65e8ad2 100644
2488 --- a/lib/log.c
2489 +++ b/lib/log.c
2490 @@ -27,11 +27,6 @@
2491
2492  #include "automount.h"
2493
2494 -/*
2495 -struct syslog_data syslog_context = AUTOFS_SYSLOG_CONTEXT;
2496 -struct syslog_data *slc = &syslog_context;
2497 -*/
2498 -
2499  static unsigned int syslog_open = 0;
2500  static unsigned int logging_to_syslog = 0;
2501
2502 @@ -39,32 +34,44 @@ static unsigned int logging_to_syslog = 0;
2503  static unsigned int do_verbose = 0;            /* Verbose feedback option */
2504  static unsigned int do_debug = 0;              /* Full debug output */
2505
2506 -static void null(unsigned int logopt, const char *msg, ...) { }
2507 -
2508 -void (*log_info)(unsigned int logopt, const char* msg, ...) = null;
2509 -void (*log_notice)(unsigned int logopt, const char* msg, ...) = null;
2510 -void (*log_warn)(unsigned int logopt, const char* msg, ...) = null;
2511 -void (*log_error)(unsigned int logopt, const char* msg, ...) = null;
2512 -void (*log_crit)(unsigned int logopt, const char* msg, ...) = null;
2513 -void (*log_debug)(unsigned int logopt, const char* msg, ...) = null;
2514 -
2515  void set_log_norm(void)
2516  {
2517         do_verbose = 0;
2518         do_debug = 0;
2519 +       return;
2520  }
2521
2522  void set_log_verbose(void)
2523  {
2524         do_verbose = 1;
2525 +       return;
2526  }
2527
2528  void set_log_debug(void)
2529  {
2530         do_debug = 1;
2531 +       return;
2532 +}
2533 +
2534 +void set_log_norm_ap(struct autofs_point *ap)
2535 +{
2536 +       ap->logopt = LOGOPT_ERROR;
2537 +       return;
2538 +}
2539 +
2540 +void set_log_verbose_ap(struct autofs_point *ap)
2541 +{
2542 +       ap->logopt = LOGOPT_VERBOSE;
2543 +       return;
2544 +}
2545 +
2546 +void set_log_debug_ap(struct autofs_point *ap)
2547 +{
2548 +       ap->logopt = LOGOPT_DEBUG;
2549 +       return;
2550  }
2551
2552 -static void syslog_info(unsigned int logopt, const char *msg, ...)
2553 +void log_info(unsigned int logopt, const char *msg, ...)
2554  {
2555         unsigned int opt_log = logopt & (LOGOPT_DEBUG | LOGOPT_VERBOSE);
2556         va_list ap;
2557 @@ -73,11 +80,18 @@ static void syslog_info(unsigned int logopt, const char *msg, ...)
2558                 return;
2559
2560         va_start(ap, msg);
2561 -       vsyslog(LOG_INFO, msg, ap);
2562 +       if (logging_to_syslog)
2563 +               vsyslog(LOG_INFO, msg, ap);
2564 +       else {
2565 +               vfprintf(stderr, msg, ap);
2566 +               fputc('\n', stderr);
2567 +       }
2568         va_end(ap);
2569 +
2570 +       return;
2571  }
2572
2573 -static void syslog_notice(unsigned int logopt, const char *msg, ...)
2574 +void log_notice(unsigned int logopt, const char *msg, ...)
2575  {
2576         unsigned int opt_log = logopt & (LOGOPT_DEBUG | LOGOPT_VERBOSE);
2577         va_list ap;
2578 @@ -86,11 +100,18 @@ static void syslog_notice(unsigned int logopt, const char *msg, ...)
2579                 return;
2580
2581         va_start(ap, msg);
2582 -       vsyslog(LOG_NOTICE, msg, ap);
2583 +       if (logging_to_syslog)
2584 +               vsyslog(LOG_NOTICE, msg, ap);
2585 +       else {
2586 +               vfprintf(stderr, msg, ap);
2587 +               fputc('\n', stderr);
2588 +       }
2589         va_end(ap);
2590 +
2591 +       return;
2592  }
2593
2594 -static void syslog_warn(unsigned int logopt, const char *msg, ...)
2595 +void log_warn(unsigned int logopt, const char *msg, ...)
2596  {
2597         unsigned int opt_log = logopt & (LOGOPT_DEBUG | LOGOPT_VERBOSE);
2598         va_list ap;
2599 @@ -99,70 +120,79 @@ static void syslog_warn(unsigned int logopt, const char *msg, ...)
2600                 return;
2601
2602         va_start(ap, msg);
2603 -       vsyslog(LOG_WARNING, msg, ap);
2604 +       if (logging_to_syslog)
2605 +               vsyslog(LOG_WARNING, msg, ap);
2606 +       else {
2607 +               vfprintf(stderr, msg, ap);
2608 +               fputc('\n', stderr);
2609 +       }
2610         va_end(ap);
2611 +
2612 +       return;
2613  }
2614
2615 -static void syslog_err(unsigned int logopt, const char *msg, ...)
2616 +void log_error(unsigned logopt, const char *msg, ...)
2617  {
2618         va_list ap;
2619 +
2620         va_start(ap, msg);
2621 -       vsyslog(LOG_ERR, msg, ap);
2622 +       if (logging_to_syslog)
2623 +               vsyslog(LOG_ERR, msg, ap);
2624 +       else {
2625 +               vfprintf(stderr, msg, ap);
2626 +               fputc('\n', stderr);
2627 +       }
2628         va_end(ap);
2629 +       return;
2630  }
2631
2632 -static void syslog_crit(unsigned int logopt, const char *msg, ...)
2633 +void log_crit(unsigned logopt, const char *msg, ...)
2634  {
2635         va_list ap;
2636 +
2637         va_start(ap, msg);
2638 -       vsyslog(LOG_CRIT, msg, ap);
2639 +       if (logging_to_syslog)
2640 +               vsyslog(LOG_CRIT, msg, ap);
2641 +       else {
2642 +               vfprintf(stderr, msg, ap);
2643 +               fputc('\n', stderr);
2644 +       }
2645         va_end(ap);
2646 +       return;
2647  }
2648
2649 -static void syslog_debug(unsigned int logopt, const char *msg, ...)
2650 +void log_debug(unsigned int logopt, const char *msg, ...)
2651  {
2652 +       unsigned int opt_log = logopt & LOGOPT_DEBUG;
2653         va_list ap;
2654
2655 -       if (!do_debug && !(logopt & LOGOPT_DEBUG))
2656 +       if (!do_debug && !opt_log)
2657                 return;
2658
2659         va_start(ap, msg);
2660 -       vsyslog(LOG_DEBUG, msg, ap);
2661 +       if (logging_to_syslog)
2662 +               vsyslog(LOG_WARNING, msg, ap);
2663 +       else {
2664 +               vfprintf(stderr, msg, ap);
2665 +               fputc('\n', stderr);
2666 +       }
2667         va_end(ap);
2668 +
2669 +       return;
2670  }
2671
2672 -static void to_stderr(unsigned int logopt, const char *msg, ...)
2673 +void logmsg(const char *msg, ...)
2674  {
2675         va_list ap;
2676         va_start(ap, msg);
2677 -       vfprintf(stderr, msg, ap);
2678 -       fputc('\n',stderr);
2679 -       va_end(ap);
2680 -}
2681 -
2682 -void set_mnt_logging(struct autofs_point *ap)
2683 -{
2684 -       unsigned int opt_verbose = ap->logopt & LOGOPT_VERBOSE;
2685 -       unsigned int opt_debug = ap->logopt & LOGOPT_DEBUG;
2686 -
2687 -       if (opt_debug) {
2688 -               if (logging_to_syslog)
2689 -                       log_debug = syslog_debug;
2690 -               else
2691 -                       log_debug = to_stderr;
2692 -       }
2693 -
2694 -       if (opt_verbose || opt_debug) {
2695 -               if (logging_to_syslog) {
2696 -                       log_info = syslog_info;
2697 -                       log_notice = syslog_notice;
2698 -                       log_warn = syslog_warn;
2699 -               } else {
2700 -                       log_info = to_stderr;
2701 -                       log_notice = to_stderr;
2702 -                       log_warn = to_stderr;
2703 -               }
2704 +       if (logging_to_syslog)
2705 +               vsyslog(LOG_CRIT, msg, ap);
2706 +       else {
2707 +               vfprintf(stderr, msg, ap);
2708 +               fputc('\n', stderr);
2709         }
2710 +       va_end(ap);
2711 +       return;
2712  }
2713
2714  void log_to_syslog(void)
2715 @@ -175,31 +205,13 @@ void log_to_syslog(void)
2716                 openlog("automount", LOG_PID, LOG_DAEMON);
2717         }
2718
2719 -       if (do_debug)
2720 -               log_debug = syslog_debug;
2721 -       else
2722 -               log_debug = null;
2723 -
2724 -       if (do_verbose || do_debug) {
2725 -               log_info = syslog_info;
2726 -               log_notice = syslog_notice;
2727 -               log_warn = syslog_warn;
2728 -       } else {
2729 -               log_info = null;
2730 -               log_notice = null;
2731 -               log_warn = null;
2732 -       }
2733 -
2734 -       log_error = syslog_err;
2735 -       log_crit = syslog_crit;
2736 -
2737         logging_to_syslog = 1;
2738
2739         /* Redirect all our file descriptors to /dev/null */
2740         nullfd = open("/dev/null", O_RDWR);
2741         if (nullfd < 0) {
2742                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
2743 -               syslog_crit(LOGOPT_ANY, "cannot open /dev/null: %s", estr);
2744 +               fprintf(stderr, "cannot open /dev/null: %s", estr);
2745                 exit(1);
2746         }
2747
2748 @@ -207,13 +219,15 @@ void log_to_syslog(void)
2749             dup2(nullfd, STDOUT_FILENO) < 0 ||
2750             dup2(nullfd, STDERR_FILENO) < 0) {
2751                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
2752 -               syslog_crit(LOGOPT_ANY,
2753 -                           "redirecting file descriptors failed: %s", estr);
2754 +               fprintf(stderr,
2755 +                       "redirecting file descriptors failed: %s", estr);
2756                 exit(1);
2757         }
2758
2759         if (nullfd > 2)
2760                 close(nullfd);
2761 +
2762 +       return;
2763  }
2764
2765  void log_to_stderr(void)
2766 @@ -223,23 +237,7 @@ void log_to_stderr(void)
2767                 closelog();
2768         }
2769
2770 -       if (do_debug)
2771 -               log_debug = to_stderr;
2772 -       else
2773 -               log_debug = null;
2774 -
2775 -       if (do_verbose || do_debug) {
2776 -               log_info = to_stderr;
2777 -               log_notice = to_stderr;
2778 -               log_warn = to_stderr;
2779 -       } else {
2780 -               log_info = null;
2781 -               log_notice = null;
2782 -               log_warn = null;
2783 -       }
2784 -
2785 -       log_error = to_stderr;
2786 -       log_crit = to_stderr;
2787 -
2788         logging_to_syslog = 0;
2789 +
2790 +       return;
2791  }
2792 diff --git a/lib/macros.c b/lib/macros.c
2793 index 936ae06..fa6db8e 100644
2794 --- a/lib/macros.c
2795 +++ b/lib/macros.c
2796 @@ -50,8 +50,7 @@ void dump_table(struct substvar *table)
2797                 fatal(status);
2798
2799         while (lv) {
2800 -               debug(LOGOPT_NONE,
2801 -                     "lv->def %s lv->val %s lv->next %p",
2802 +               logmsg("lv->def %s lv->val %s lv->next %p",
2803                       lv->def, lv->val, lv->next);
2804                 lv = lv->next;
2805         }
2806 diff --git a/lib/master.c b/lib/master.c
2807 index abc3bc2..2e24ad0 100644
2808 --- a/lib/master.c
2809 +++ b/lib/master.c
2810 @@ -524,8 +524,7 @@ void master_source_writelock(struct master_mapent *entry)
2811
2812         status = pthread_rwlock_wrlock(&entry->source_lock);
2813         if (status) {
2814 -               error(LOGOPT_ANY,
2815 -                     "master_mapent source write lock failed");
2816 +               logmsg("master_mapent source write lock failed");
2817                 fatal(status);
2818         }
2819         return;
2820 @@ -537,8 +536,7 @@ void master_source_readlock(struct master_mapent *entry)
2821
2822         status = pthread_rwlock_rdlock(&entry->source_lock);
2823         if (status) {
2824 -               error(LOGOPT_ANY,
2825 -                     "master_mapent source read lock failed");
2826 +               logmsg("master_mapent source read lock failed");
2827                 fatal(status);
2828         }
2829         return;
2830 @@ -550,8 +548,7 @@ void master_source_unlock(struct master_mapent *entry)
2831
2832         status = pthread_rwlock_unlock(&entry->source_lock);
2833         if (status) {
2834 -               error(LOGOPT_ANY,
2835 -                     "master_mapent source unlock failed");
2836 +               logmsg("master_mapent source unlock failed");
2837                 fatal(status);
2838         }
2839         return;
2840 @@ -572,7 +569,7 @@ void master_source_current_wait(struct master_mapent *entry)
2841
2842         status = pthread_mutex_lock(&entry->current_mutex);
2843         if (status) {
2844 -               error(LOGOPT_ANY, "entry current source lock failed");
2845 +               logmsg("entry current source lock failed");
2846                 fatal(status);
2847         }
2848
2849 @@ -580,8 +577,7 @@ void master_source_current_wait(struct master_mapent *entry)
2850                 status = pthread_cond_wait(
2851                                 &entry->current_cond, &entry->current_mutex);
2852                 if (status) {
2853 -                       error(LOGOPT_ANY,
2854 -                             "entry current source condition wait failed");
2855 +                       logmsg("entry current source condition wait failed");
2856                         fatal(status);
2857                 }
2858         }
2859 @@ -595,14 +591,13 @@ void master_source_current_signal(struct master_mapent *entry)
2860
2861         status = pthread_cond_signal(&entry->current_cond);
2862         if (status) {
2863 -               error(LOGOPT_ANY,
2864 -                     "entry current source condition signal failed");
2865 +               logmsg("entry current source condition signal failed");
2866                 fatal(status);
2867         }
2868
2869         status = pthread_mutex_unlock(&entry->current_mutex);
2870         if (status) {
2871 -               error(LOGOPT_ANY, "entry current source unlock failed");
2872 +               logmsg("entry current source unlock failed");
2873                 fatal(status);
2874         }
2875
2876 @@ -770,6 +765,7 @@ struct master *master_new(const char *name, unsigned int timeout, unsigned int g
2877         master->default_ghost = ghost;
2878         master->default_timeout = timeout;
2879         master->default_logging = defaults_get_logging();
2880 +       master->logopt = master->default_logging;
2881
2882         INIT_LIST_HEAD(&master->mounts);
2883
2884 @@ -778,11 +774,12 @@ struct master *master_new(const char *name, unsigned int timeout, unsigned int g
2885
2886  int master_read_master(struct master *master, time_t age, int readall)
2887  {
2888 +       unsigned int logopt = master->logopt;
2889         struct mapent_cache *nc;
2890
2891         nc = cache_init_null_cache(master);
2892         if (!nc) {
2893 -               error(LOGOPT_ANY,
2894 +               error(logopt,
2895                       "failed to init null map cache for %s", master->name);
2896                 return 0;
2897         }
2898 @@ -791,7 +788,7 @@ int master_read_master(struct master *master, time_t age, int readall)
2899         master_init_scan();
2900
2901         if (!lookup_nss_read_master(master, age)) {
2902 -               error(LOGOPT_ANY,
2903 +               error(logopt,
2904                       "can't read master map %s", master->name);
2905                 return 0;
2906         }
2907 @@ -802,7 +799,7 @@ int master_read_master(struct master *master, time_t age, int readall)
2908
2909         if (list_empty(&master->mounts)) {
2910                 master_mutex_unlock();
2911 -               warn(LOGOPT_ANY, "no mounts in table");
2912 +               warn(logopt, "no mounts in table");
2913                 return 1;
2914         }
2915
2916 @@ -934,6 +931,7 @@ void master_notify_state_change(struct master *master, int sig)
2917         struct autofs_point *ap;
2918         struct list_head *p;
2919         int state_pipe, cur_state;
2920 +       unsigned int logopt;
2921
2922         pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);
2923         master_mutex_lock();
2924 @@ -944,6 +942,7 @@ void master_notify_state_change(struct master *master, int sig)
2925                 entry = list_entry(p, struct master_mapent, list);
2926
2927                 ap = entry->ap;
2928 +               logopt = ap->logopt;
2929
2930                 state_mutex_lock(ap);
2931
2932 @@ -978,7 +977,7 @@ void master_notify_state_change(struct master *master, int sig)
2933                 }
2934  next:
2935                 if (next != ST_INVAL)
2936 -                       debug(ap->logopt,
2937 +                       debug(logopt,
2938                               "sig %d switching %s from %d to %d",
2939                               sig, ap->path, ap->state, next);
2940
2941 @@ -1230,6 +1229,11 @@ int master_list_empty(struct master *master)
2942         return res;
2943  }
2944
2945 +inline unsigned int master_get_logopt(void)
2946 +{
2947 +       return master_list ? master_list->logopt : LOGOPT_NONE;
2948 +}
2949 +
2950  int master_kill(struct master *master)
2951  {
2952         if (!list_empty(&master->mounts))
2953 @@ -1251,6 +1255,6 @@ void dump_master(struct master *master)
2954         head = &master->mounts;
2955         list_for_each(p, head) {
2956                 struct master_mapent *this = list_entry(p, struct master_mapent, list);
2957 -               debug(LOGOPT_ANY, "path %s", this->path);
2958 +               logmsg("path %s", this->path);
2959         }
2960  }
2961 diff --git a/lib/master_parse.y b/lib/master_parse.y
2962 index 70b48be..a767f9e 100644
2963 --- a/lib/master_parse.y
2964 +++ b/lib/master_parse.y
2965 @@ -585,13 +585,13 @@ static char *master_strdup(char *str)
2966
2967  static int master_error(const char *s)
2968  {
2969 -       error(LOGOPT_ANY, "%s while parsing map.", s);
2970 +       logmsg("%s while parsing map.", s);
2971         return 0;
2972  }
2973
2974  static int master_notify(const char *s)
2975  {
2976 -       warn(LOGOPT_ANY, "syntax error in map near [ %s ]", s);
2977 +       logmsg("syntax error in map near [ %s ]", s);
2978         return(0);
2979  }
2980
2981 @@ -704,6 +704,7 @@ int master_parse_entry(const char *buffer, unsigned int default_timeout, unsigne
2982         struct master_mapent *entry, *new;
2983         struct map_source *source;
2984         unsigned int logopt = logging;
2985 +       unsigned int m_logopt = master->logopt;
2986         int ret;
2987
2988         local_init_vars();
2989 @@ -758,8 +759,8 @@ int master_parse_entry(const char *buffer, unsigned int default_timeout, unsigne
2990         } else {
2991                 if (entry->age && entry->age == age) {
2992                         if (strcmp(path, "/-")) {
2993 -                               warn(LOGOPT_VERBOSE,
2994 -                                    "ignoring duplicate indirect mount %s",
2995 +                               info(m_logopt,
2996 +                                   "ignoring duplicate indirect mount %s",
2997                                      path);
2998                                 local_free_vars();
2999                                 return 0;
3000 @@ -770,13 +771,12 @@ int master_parse_entry(const char *buffer, unsigned int default_timeout, unsigne
3001         if (!entry->ap) {
3002                 ret = master_add_autofs_point(entry, timeout, logopt, ghost, 0);
3003                 if (!ret) {
3004 -                       error(LOGOPT_ANY, "failed to add autofs_point");
3005 +                       error(m_logopt, "failed to add autofs_point");
3006                         if (new)
3007                                 master_free_mapent(new);
3008                         local_free_vars();
3009                         return 0;
3010                 }
3011 -               set_mnt_logging(entry->ap);
3012         } else {
3013                 struct autofs_point *ap = entry->ap;
3014                 time_t tout = timeout;
3015 @@ -786,14 +786,11 @@ int master_parse_entry(const char *buffer, unsigned int default_timeout, unsigne
3016                  * use the ghost, log and timeout of the first
3017                  */
3018                 if (entry->age < age) {
3019 -                       ap->ghost = ghost;
3020 -                       ap->logopt = logopt;
3021                         ap->exp_timeout = timeout;
3022                         ap->exp_runfreq = (ap->exp_timeout + CHECK_RATIO - 1) / CHECK_RATIO;
3023                         if (ap->ioctlfd != -1 && ap->type == LKP_INDIRECT)
3024                                 ioctl(ap->ioctlfd, AUTOFS_IOC_SETTIMEOUT, &tout);
3025                 }
3026 -               set_mnt_logging(ap);
3027         }
3028         entry->ap->random_selection = random_selection;
3029
3030 @@ -809,7 +806,7 @@ int master_parse_entry(const char *buffer, unsigned int default_timeout, unsigne
3031         source = master_add_map_source(entry, type, format, age,
3032                                         local_argc, (const char **) local_argv);
3033         if (!source) {
3034 -               error(LOGOPT_ANY, "failed to add source");
3035 +               error(m_logopt, "failed to add source");
3036                 if (new)
3037                         master_free_mapent(new);
3038                 local_free_vars();
3039 @@ -817,9 +814,9 @@ int master_parse_entry(const char *buffer, unsigned int default_timeout, unsigne
3040         }
3041
3042         if (!source->mc) {
3043 -               source->mc = cache_init(source);
3044 +               source->mc = cache_init(entry->ap, source);
3045                 if (!source->mc) {
3046 -                       error(LOGOPT_ANY, "failed to init source cache");
3047 +                       error(m_logopt, "failed to init source cache");
3048                         if (new)
3049                                 master_free_mapent(new);
3050                         local_free_vars();
3051 diff --git a/lib/master_tok.l b/lib/master_tok.l
3052 index 2735223..00cd223 100644
3053 --- a/lib/master_tok.l
3054 +++ b/lib/master_tok.l
3055 @@ -368,7 +368,7 @@ int master_wrap(void)
3056
3057  static void master_echo(void)
3058  {
3059 -       debug(LOGOPT_NONE, "%s", master_text);
3060 +       logmsg("%s", master_text);
3061         return;
3062  }
3063
3064 diff --git a/lib/mounts.c b/lib/mounts.c
3065 index 0e428e8..425a65a 100644
3066 --- a/lib/mounts.c
3067 +++ b/lib/mounts.c
3068 @@ -126,7 +126,7 @@ char *make_options_string(char *path, int pipefd, char *extra)
3069
3070         options = malloc(MAX_OPTIONS_LEN + 1);
3071         if (!options) {
3072 -               crit(LOGOPT_ANY, "can't malloc options string");
3073 +               logerr("can't malloc options string");
3074                 return NULL;
3075         }
3076
3077 @@ -141,13 +141,12 @@ char *make_options_string(char *path, int pipefd, char *extra)
3078                         AUTOFS_MAX_PROTO_VERSION);
3079
3080         if (len >= MAX_OPTIONS_LEN) {
3081 -               crit(LOGOPT_ANY, "buffer to small for options - truncated");
3082 +               logerr("buffer to small for options - truncated");
3083                 len = MAX_OPTIONS_LEN - 1;
3084         }
3085
3086         if (len < 0) {
3087 -               crit(LOGOPT_ANY,
3088 -                    "failed to malloc autofs mount options for %s", path);
3089 +               logerr("failed to malloc autofs mount options for %s", path);
3090                 free(options);
3091                 return NULL;
3092         }
3093 @@ -163,7 +162,7 @@ char *make_mnt_name_string(char *path)
3094
3095         mnt_name = malloc(MAX_MNT_NAME_LEN + 1);
3096         if (!mnt_name) {
3097 -               crit(LOGOPT_ANY, "can't malloc mnt_name string");
3098 +               logerr("can't malloc mnt_name string");
3099                 return NULL;
3100         }
3101
3102 @@ -171,13 +170,12 @@ char *make_mnt_name_string(char *path)
3103                         mnt_name_template, (unsigned) getpid());
3104
3105         if (len >= MAX_MNT_NAME_LEN) {
3106 -               crit(LOGOPT_ANY, "buffer to small for mnt_name - truncated");
3107 +               logerr("buffer to small for mnt_name - truncated");
3108                 len = MAX_MNT_NAME_LEN - 1;
3109         }
3110
3111         if (len < 0) {
3112 -               crit(LOGOPT_ANY,
3113 -                    "failed setting up mnt_name for autofs path %s", path);
3114 +               logerr("failed setting up mnt_name for autofs path %s", path);
3115                 free(mnt_name);
3116                 return NULL;
3117         }
3118 @@ -207,7 +205,7 @@ struct mnt_list *get_mnt_list(const char *table, const char *path, int include)
3119         tab = setmntent(table, "r");
3120         if (!tab) {
3121                 char *estr = strerror_r(errno, buf, PATH_MAX - 1);
3122 -               error(LOGOPT_ANY, "setmntent: %s", estr);
3123 +               logerr("setmntent: %s", estr);
3124                 return NULL;
3125         }
3126
3127 @@ -398,7 +396,7 @@ int is_mounted(const char *table, const char *path, unsigned int type)
3128         tab = setmntent(table, "r");
3129         if (!tab) {
3130                 char *estr = strerror_r(errno, buf, PATH_MAX - 1);
3131 -               error(LOGOPT_ANY, "setmntent: %s", estr);
3132 +               logerr("setmntent: %s", estr);
3133                 return 0;
3134         }
3135
3136 @@ -443,7 +441,7 @@ int has_fstab_option(const char *opt)
3137         tab = setmntent(_PATH_MNTTAB, "r");
3138         if (!tab) {
3139                 char *estr = strerror_r(errno, buf, PATH_MAX - 1);
3140 -               error(LOGOPT_ANY, "setmntent: %s", estr);
3141 +               logerr("setmntent: %s", estr);
3142                 return 0;
3143         }
3144
3145 @@ -471,7 +469,7 @@ char *find_mnt_ino(const char *table, dev_t dev, ino_t ino)
3146         tab = setmntent(table, "r");
3147         if (!tab) {
3148                 char *estr = strerror_r(errno, buf, (size_t) PATH_MAX - 1);
3149 -               error(LOGOPT_ANY, "setmntent: %s", estr);
3150 +               logerr("setmntent: %s", estr);
3151                 return 0;
3152         }
3153
3154 @@ -667,7 +665,7 @@ struct mnt_list *tree_make_mnt_tree(const char *table, const char *path)
3155         tab = setmntent(table, "r");
3156         if (!tab) {
3157                 char *estr = strerror_r(errno, buf, PATH_MAX - 1);
3158 -               error(LOGOPT_ANY, "setmntent: %s", estr);
3159 +               logerr("setmntent: %s", estr);
3160                 return NULL;
3161         }
3162
3163 diff --git a/lib/nss_parse.y b/lib/nss_parse.y
3164 index e559696..90b7d25 100644
3165 --- a/lib/nss_parse.y
3166 +++ b/lib/nss_parse.y
3167 @@ -127,13 +127,13 @@ status_exp: STATUS EQUAL ACTION
3168
3169  static int nss_ignore(const char *s)
3170  {
3171 -       msg("ignored invalid nsswitch config near [ %s ]", s);
3172 +       logmsg("ignored invalid nsswitch config near [ %s ]", s);
3173         return(0);
3174  }
3175
3176  static int nss_error(const char *s)
3177  {
3178 -       msg("syntax error in nsswitch config near [ %s ]\n", s);
3179 +       logmsg("syntax error in nsswitch config near [ %s ]\n", s);
3180         return(0);
3181  }
3182
3183 @@ -167,7 +167,7 @@ int nsswitch_parse(struct list_head *list)
3184
3185         nsswitch = fopen(NSSWITCH_FILE, "r");
3186         if (!nsswitch) {
3187 -               error(LOGOPT_ANY, "couldn't open %s\n", NSSWITCH_FILE);
3188 +               logerr("couldn't open %s\n", NSSWITCH_FILE);
3189                 return 1;
3190         }
3191
3192 diff --git a/lib/nss_tok.l b/lib/nss_tok.l
3193 index f96b47f..c435b63 100644
3194 --- a/lib/nss_tok.l
3195 +++ b/lib/nss_tok.l
3196 @@ -135,6 +135,6 @@ int nss_wrap(void)
3197
3198  static void nss_echo(void)
3199  {
3200 -       msg("%s", nss_text);
3201 +       logmsg("%s", nss_text);
3202         return;
3203  }
3204 diff --git a/lib/parse_subs.c b/lib/parse_subs.c
3205 index 3627f44..5422fef 100644
3206 --- a/lib/parse_subs.c
3207 +++ b/lib/parse_subs.c
3208 @@ -337,9 +337,9 @@ int umount_ent(struct autofs_point *ap, const char *path)
3209          * and EBADSLT relates to CD changer not responding.
3210          */
3211         if (!status && (S_ISDIR(st.st_mode) && st.st_dev != ap->dev)) {
3212 -               rv = spawn_umount(log_debug, path, NULL);
3213 +               rv = spawn_umount(ap->logopt, path, NULL);
3214         } else if (is_smbfs && (sav_errno == EIO || sav_errno == EBADSLT)) {
3215 -               rv = spawn_umount(log_debug, path, NULL);
3216 +               rv = spawn_umount(ap->logopt, path, NULL);
3217         }
3218
3219         /* We are doing a forced shutcwdown down so unlink busy mounts */
3220 @@ -356,8 +356,8 @@ int umount_ent(struct autofs_point *ap, const char *path)
3221                 }
3222
3223                 if (ap->state == ST_SHUTDOWN_FORCE) {
3224 -                       msg("forcing umount of %s", path);
3225 -                       rv = spawn_umount(log_debug, "-l", path, NULL);
3226 +                       info(ap->logopt, "forcing umount of %s", path);
3227 +                       rv = spawn_umount(ap->logopt, "-l", path, NULL);
3228                 }
3229
3230                 /*
3231 @@ -503,7 +503,7 @@ int umount_multi_triggers(struct autofs_point *ap, char *root, struct mapent *me
3232                  * the offset triggers back.
3233                  */
3234                 if (is_mounted(_PATH_MOUNTED, root, MNTS_REAL)) {
3235 -                       msg("unmounting dir = %s", root);
3236 +                       info(ap->logopt, "unmounting dir = %s", root);
3237                         if (umount_ent(ap, root)) {
3238                                 if (!mount_multi_triggers(ap, root, me, "/"))
3239                                         warn(ap->logopt,
3240 diff --git a/lib/rpc_subs.c b/lib/rpc_subs.c
3241 index d79a94f..5797639 100644
3242 --- a/lib/rpc_subs.c
3243 +++ b/lib/rpc_subs.c
3244 @@ -96,7 +96,7 @@ static CLIENT *create_udp_client(struct conn_info *info)
3245         if (ret || !result) {
3246                 int err = ghn_errno == -1 ? errno : ghn_errno;
3247                 char *estr = strerror_r(err, buf, HOST_ENT_BUF_SIZE);
3248 -               error(LOGOPT_ANY, "hostname lookup failed: %s", estr);
3249 +               logerr("hostname lookup failed: %s", estr);
3250                 goto out_close;
3251         }
3252         memcpy(&raddr.sin_addr.s_addr, php->h_addr, php->h_length);
3253 @@ -305,7 +305,7 @@ static CLIENT *create_tcp_client(struct conn_info *info)
3254         if (ret || !result) {
3255                 int err = ghn_errno == -1 ? errno : ghn_errno;
3256                 char *estr =  strerror_r(err, buf, HOST_ENT_BUF_SIZE);
3257 -               error(LOGOPT_ANY, "hostname lookup failed: %s", estr);
3258 +               logerr("hostname lookup failed: %s", estr);
3259                 goto out_close;
3260         }
3261         memcpy(&addr.sin_addr.s_addr, php->h_addr, php->h_length);
3262 diff --git a/man/automount.8 b/man/automount.8
3263 index e203a3e..5cd63c7 100644
3264 --- a/man/automount.8
3265 +++ b/man/automount.8
3266 @@ -62,6 +62,22 @@ setting.
3267  .TP
3268  .I "\-V, \-\-version"
3269  Display the version number, then exit.
3270 +.TP
3271 +.I "\-l, \-\-set-log-priority priority path [path,...]"
3272 +Set the daemon log priority to the specified value.  Valid values include
3273 +the numbers 0-7, or the strings emerg, alert, crit, err, warning, notice,
3274 +info, or debug. Log level debug will log everything, log levels info, warn
3275 +(or warning), or notice with enable the daemon verbose logging. Any other
3276 +level will set basic logging. Note that enabling debug or verbose
3277 +logging in the autofs global configuration will override dynamic log level
3278 +changes. For example, if verbose logging is set in the configuration then
3279 +attempting to set logging to basic logging, by using alert, crit, err
3280 +or emerg won't stop the verbose logging. However, setting logging to debug
3281 +will lead to everything (debug logging) being logged witch can then also
3282 +be disabled, returning the daemon to verbose logging.
3283 +.P
3284 +The \fIpath\fP argument corresponds to the automounted
3285 +path name as specified in the master map.
3286  .SH ARGUMENTS
3287  \fBautomount\fP takes one optional argument, the name of the master map to
3288  use.
3289 diff --git a/modules/cyrus-sasl.c b/modules/cyrus-sasl.c
3290 index 68e5dd7..18733f3 100644
3291 --- a/modules/cyrus-sasl.c
3292 +++ b/modules/cyrus-sasl.c
3293 @@ -96,18 +96,18 @@ sasl_log_func(void *context, int level, const char *message)
3294         switch (level) {
3295         case SASL_LOG_ERR:
3296         case SASL_LOG_FAIL:
3297 -               error(LOGOPT_ANY, "%s", message);
3298 +               logerr("%s", message);
3299                 break;
3300         case SASL_LOG_WARN:
3301 -               warn(LOGOPT_ANY, "%s", message);
3302 +               logmsg("%s", message);
3303                 break;
3304         case SASL_LOG_NOTE:
3305 -               info(LOGOPT_ANY, "%s", message);
3306 +               logmsg("%s", message);
3307                 break;
3308         case SASL_LOG_DEBUG:
3309         case SASL_LOG_TRACE:
3310         case SASL_LOG_PASS:
3311 -               debug(LOGOPT_NONE, "%s", message);
3312 +               debug(LOGOPT_DEBUG, "%s", message);
3313                 break;
3314         default:
3315                 break;
3316 @@ -129,7 +129,7 @@ getuser_func(void *context, int id, const char **result, unsigned *len)
3317                         *len = strlen(sasl_auth_id);
3318                 break;
3319         default:
3320 -               error(LOGOPT_ANY, "unknown id in request: %d", id);
3321 +               error(LOGOPT_VERBOSE, "unknown id in request: %d", id);
3322                 return SASL_FAIL;
3323         }
3324
3325 @@ -166,7 +166,7 @@ getpass_func(sasl_conn_t *conn, void *context, int id, sasl_secret_t **psecret)
3326   *                the returned data.
3327   */
3328  char **
3329 -get_server_SASL_mechanisms(LDAP *ld)
3330 +get_server_SASL_mechanisms(unsigned logopt, LDAP *ld)
3331  {
3332         int ret;
3333         const char *saslattrlist[] = {"supportedSASLmechanisms", NULL};
3334 @@ -178,7 +178,7 @@ get_server_SASL_mechanisms(LDAP *ld)
3335                                 NULL, NULL,
3336                                 NULL, LDAP_NO_LIMIT, &results);
3337         if (ret != LDAP_SUCCESS) {
3338 -               error(LOGOPT_ANY, "%s", ldap_err2string(ret));
3339 +               error(logopt, "%s", ldap_err2string(ret));
3340                 return NULL;
3341         }
3342
3343 @@ -186,7 +186,7 @@ get_server_SASL_mechanisms(LDAP *ld)
3344         if (entry == NULL) {
3345                 /* No root DSE. (!) */
3346                 ldap_msgfree(results);
3347 -               debug(LOGOPT_NONE,
3348 +               debug(logopt,
3349                       "a lookup of \"supportedSASLmechanisms\" returned "
3350                       "no results.");
3351                 return NULL;
3352 @@ -196,7 +196,7 @@ get_server_SASL_mechanisms(LDAP *ld)
3353         ldap_msgfree(results);
3354         if (mechanisms == NULL) {
3355                 /* Well, that was a waste of time. */
3356 -               msg("No SASL authentication mechanisms are supported"
3357 +               info(logopt, "No SASL authentication mechanisms are supported"
3358                     " by the LDAP server.");
3359                 return NULL;
3360         }
3361 @@ -208,7 +208,7 @@ get_server_SASL_mechanisms(LDAP *ld)
3362   *  Returns 0 upon successful connect, -1 on failure.
3363   */
3364  int
3365 -do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3366 +do_sasl_bind(unsigned logopt, LDAP *ld, sasl_conn_t *conn, const char **clientout,
3367              unsigned int *clientoutlen, const char *auth_mech, int sasl_result)
3368  {
3369         int ret, msgid, bind_result;
3370 @@ -226,7 +226,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3371                                      &client_cred : NULL,
3372                                      NULL, NULL, &msgid);
3373                 if (ret != LDAP_SUCCESS) {
3374 -                       crit(LOGOPT_ANY,
3375 +                       crit(logopt,
3376                              "Error sending sasl_bind request to "
3377                              "the server: %s", ldap_err2string(ret));
3378                         return -1;
3379 @@ -236,7 +236,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3380                 results = NULL;
3381                 ret = ldap_result(ld, msgid, LDAP_MSG_ALL, NULL, &results);
3382                 if (ret != LDAP_RES_BIND) {
3383 -                       crit(LOGOPT_ANY,
3384 +                       crit(logopt,
3385                              "Error while waiting for response to "
3386                              "sasl_bind request: %s", ldap_err2string(ret));
3387                         return -1;
3388 @@ -264,7 +264,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3389                         ret = ldap_get_option(ld, LDAP_OPT_RESULT_CODE,
3390                                               &bind_result);
3391                         if (ret != LDAP_SUCCESS) {
3392 -                               crit(LOGOPT_ANY,
3393 +                               crit(logopt,
3394                                      "Error retrieving response to sasl_bind "
3395                                      "request: %s", ldap_err2string(ret));
3396                                 ret = -1;
3397 @@ -277,7 +277,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3398                                 bind_result = ret;
3399                                 break;
3400                         default:
3401 -                               warn(LOGOPT_ANY,
3402 +                               warn(logopt,
3403                                      "Error parsing response to sasl_bind "
3404                                      "request: %s.", ldap_err2string(ret));
3405                                 break;
3406 @@ -299,7 +299,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3407                 expected_data = sasl_result == SASL_CONTINUE;
3408
3409                 if (have_data && !expected_data) {
3410 -                       warn(LOGOPT_ANY,
3411 +                       warn(logopt,
3412                              "The LDAP server sent data in response to our "
3413                              "bind request, but indicated that the bind was "
3414                              "complete. LDAP SASL bind with mechansim %s "
3415 @@ -308,7 +308,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3416                         break;
3417                 }
3418                 if (expected_data && !have_data) {
3419 -                       warn(LOGOPT_ANY,
3420 +                       warn(logopt,
3421                              "The LDAP server indicated that the LDAP SASL "
3422                              "bind was incomplete, but did not provide the "
3423                              "required data to proceed. LDAP SASL bind with "
3424 @@ -340,7 +340,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3425                          */
3426                         if ((*clientoutlen > 0) &&
3427                             (bind_result != LDAP_SASL_BIND_IN_PROGRESS)) {
3428 -                               warn(LOGOPT_ANY,
3429 +                               warn(logopt,
3430                                      "We have data for the server, "
3431                                      "but it thinks we are done!");
3432                                 /* XXX should print out debug data here */
3433 @@ -372,7 +372,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3434   *  Upon failure, -1 is returned.
3435   */
3436  int
3437 -sasl_do_kinit(struct lookup_context *ctxt)
3438 +sasl_do_kinit(unsigned logopt, struct lookup_context *ctxt)
3439  {
3440         krb5_error_code ret;
3441         krb5_principal tgs_princ, krb5_client_princ = ctxt->krb5_client_princ;
3442 @@ -384,33 +384,33 @@ sasl_do_kinit(struct lookup_context *ctxt)
3443                 return 0;
3444         ctxt->kinit_done = 1;
3445
3446 -       debug(LOGOPT_NONE,
3447 +       debug(logopt,
3448               "initializing kerberos ticket: client principal %s ",
3449               ctxt->client_princ ? "" : "autofsclient");
3450
3451         ret = krb5_init_context(&ctxt->krb5ctxt);
3452         if (ret) {
3453 -               error(LOGOPT_ANY, "krb5_init_context failed with %d", ret);
3454 +               error(logopt, "krb5_init_context failed with %d", ret);
3455                 return -1;
3456         }
3457
3458         ret = krb5_cc_resolve(ctxt->krb5ctxt, krb5ccval, &ctxt->krb5_ccache);
3459         if (ret) {
3460 -               error(LOGOPT_ANY, "krb5_cc_resolve failed with error %d",
3461 +               error(logopt, "krb5_cc_resolve failed with error %d",
3462                       ret);
3463                 krb5_free_context(ctxt->krb5ctxt);
3464                 return -1;
3465         }
3466
3467         if (ctxt->client_princ) {
3468 -               debug(LOGOPT_NONE,
3469 +               debug(logopt,
3470                       "calling krb5_parse_name on client principal %s",
3471                       ctxt->client_princ);
3472
3473                 ret = krb5_parse_name(ctxt->krb5ctxt, ctxt->client_princ,
3474                                       &krb5_client_princ);
3475                 if (ret) {
3476 -                       error(LOGOPT_ANY,
3477 +                       error(logopt,
3478                               "krb5_parse_name failed for "
3479                               "specified client principal %s",
3480                               ctxt->client_princ);
3481 @@ -419,14 +419,14 @@ sasl_do_kinit(struct lookup_context *ctxt)
3482         } else {
3483                 char *tmp_name = NULL;
3484
3485 -               debug(LOGOPT_NONE,
3486 +               debug(logopt,
3487                       "calling krb5_sname_to_principal using defaults");
3488
3489                 ret = krb5_sname_to_principal(ctxt->krb5ctxt, NULL,
3490                                         "autofsclient", KRB5_NT_SRV_HST,
3491                                         &krb5_client_princ);
3492                 if (ret) {
3493 -                       error(LOGOPT_ANY,
3494 +                       error(logopt,
3495                               "krb5_sname_to_principal failed for "
3496                               "%s with error %d",
3497                               ctxt->client_princ ? "" : "autofsclient", ret);
3498 @@ -437,13 +437,13 @@ sasl_do_kinit(struct lookup_context *ctxt)
3499                 ret = krb5_unparse_name(ctxt->krb5ctxt,
3500                                         krb5_client_princ, &tmp_name);
3501                 if (ret) {
3502 -                       debug(LOGOPT_NONE,
3503 +                       debug(logopt,
3504                               "krb5_unparse_name failed with error %d",
3505                               ret);
3506                         goto out_cleanup_cc;
3507                 }
3508
3509 -               debug(LOGOPT_NONE,
3510 +               debug(logopt,
3511                       "principal used for authentication: \"%s\"", tmp_name);
3512
3513                 krb5_free_unparsed_name(ctxt->krb5ctxt, tmp_name);
3514 @@ -458,19 +458,19 @@ sasl_do_kinit(struct lookup_context *ctxt)
3515                 krb5_princ_realm(ctxt->krb5ctxt, krb5_client_princ)->data,
3516                 0);
3517         if (ret) {
3518 -               error(LOGOPT_ANY,
3519 +               error(logopt,
3520                       "krb5_build_principal failed with error %d", ret);
3521                 goto out_cleanup_cc;
3522         }
3523
3524         ret = krb5_unparse_name(ctxt->krb5ctxt, tgs_princ, &tgs_name);
3525         if (ret) {
3526 -               error(LOGOPT_ANY, "krb5_unparse_name failed with error %d",
3527 +               error(logopt, "krb5_unparse_name failed with error %d",
3528                       ret);
3529                 goto out_cleanup_cc;
3530         }
3531
3532 -       debug(LOGOPT_NONE, "Using tgs name %s", tgs_name);
3533 +       debug(logopt, "Using tgs name %s", tgs_name);
3534
3535         memset(&my_creds, 0, sizeof(my_creds));
3536         ret = krb5_get_init_creds_keytab(ctxt->krb5ctxt, &my_creds,
3537 @@ -479,7 +479,7 @@ sasl_do_kinit(struct lookup_context *ctxt)
3538                                          0 /* relative start time */,
3539                                          tgs_name, NULL);
3540         if (ret) {
3541 -               error(LOGOPT_ANY,
3542 +               error(logopt,
3543                       "krb5_get_init_creds_keytab failed with error %d",
3544                       ret);
3545                 goto out_cleanup_unparse;
3546 @@ -500,7 +500,7 @@ sasl_do_kinit(struct lookup_context *ctxt)
3547                 fatal(status);
3548
3549         if (ret) {
3550 -               error(LOGOPT_ANY,
3551 +               error(logopt,
3552                       "krb5_cc_initialize failed with error %d", ret);
3553                 goto out_cleanup_unparse;
3554         }
3555 @@ -508,7 +508,7 @@ sasl_do_kinit(struct lookup_context *ctxt)
3556         /* and store credentials for that principal */
3557         ret = krb5_cc_store_cred(ctxt->krb5ctxt, ctxt->krb5_ccache, &my_creds);
3558         if (ret) {
3559 -               error(LOGOPT_ANY,
3560 +               error(logopt,
3561                       "krb5_cc_store_cred failed with error %d", ret);
3562                 goto out_cleanup_unparse;
3563         }
3564 @@ -516,12 +516,12 @@ sasl_do_kinit(struct lookup_context *ctxt)
3565         /* finally, set the environment variable to point to our
3566          * credentials cache */
3567         if (setenv(krb5ccenv, krb5ccval, 1) != 0) {
3568 -               error(LOGOPT_ANY, "setenv failed with %d", errno);
3569 +               error(logopt, "setenv failed with %d", errno);
3570                 goto out_cleanup_unparse;
3571         }
3572         ctxt->kinit_successful = 1;
3573
3574 -       debug(LOGOPT_NONE, "Kerberos authentication was successful!");
3575 +       debug(logopt, "Kerberos authentication was successful!");
3576
3577         krb5_free_unparsed_name(ctxt->krb5ctxt, tgs_name);
3578
3579 @@ -540,7 +540,7 @@ out_cleanup_cc:
3580         else
3581                 ret = krb5_cc_destroy(ctxt->krb5ctxt, ctxt->krb5_ccache);
3582         if (ret)
3583 -               warn(LOGOPT_ANY,
3584 +               warn(logopt,
3585                      "krb5_cc_destroy failed with non-fatal error %d", ret);
3586
3587         status = pthread_mutex_unlock(&krb5cc_mutex);
3588 @@ -559,7 +559,7 @@ out_cleanup_cc:
3589   *  Returns a valid sasl_conn_t pointer upon success, NULL on failure.
3590   */
3591  sasl_conn_t *
3592 -sasl_bind_mech(LDAP *ldap, struct lookup_context *ctxt, const char *mech)
3593 +sasl_bind_mech(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt, const char *mech)
3594  {
3595         sasl_conn_t *conn;
3596         char *tmp, *host = NULL;
3597 @@ -569,15 +569,15 @@ sasl_bind_mech(LDAP *ldap, struct lookup_context *ctxt, const char *mech)
3598         int result;
3599
3600         if (!strncmp(mech, "GSSAPI", 6)) {
3601 -               if (sasl_do_kinit(ctxt) != 0)
3602 +               if (sasl_do_kinit(logopt, ctxt) != 0)
3603                         return NULL;
3604         }
3605
3606 -       debug(LOGOPT_NONE, "Attempting sasl bind with mechanism %s", mech);
3607 +       debug(logopt, "Attempting sasl bind with mechanism %s", mech);
3608
3609         result = ldap_get_option(ldap, LDAP_OPT_HOST_NAME, &host);
3610         if (result != LDAP_SUCCESS || !host) {
3611 -               debug(LOGOPT_NONE, "failed to get hostname for connection");
3612 +               debug(logopt, "failed to get hostname for connection");
3613                 return NULL;
3614         }
3615
3616 @@ -587,7 +587,7 @@ sasl_bind_mech(LDAP *ldap, struct lookup_context *ctxt, const char *mech)
3617         /* Create a new authentication context for the service. */
3618         result = sasl_client_new("ldap", host, NULL, NULL, NULL, 0, &conn);
3619         if (result != SASL_OK) {
3620 -               error(LOGOPT_ANY, "sasl_client_new failed with error %d",
3621 +               error(logopt, "sasl_client_new failed with error %d",
3622                       result);
3623                 ldap_memfree(host);
3624                 return NULL;
3625 @@ -599,23 +599,23 @@ sasl_bind_mech(LDAP *ldap, struct lookup_context *ctxt, const char *mech)
3626
3627         /* OK and CONTINUE are the only non-fatal return codes here. */
3628         if ((result != SASL_OK) && (result != SASL_CONTINUE)) {
3629 -               error(LOGOPT_ANY, "sasl_client start failed with error: %s",
3630 +               error(logopt, "sasl_client start failed with error: %s",
3631                       sasl_errdetail(conn));
3632                 ldap_memfree(host);
3633                 sasl_dispose(&conn);
3634                 return NULL;
3635         }
3636
3637 -       result = do_sasl_bind(ldap, conn,
3638 +       result = do_sasl_bind(logopt, ldap, conn,
3639                          &clientout, &clientoutlen, chosen_mech, result);
3640         if (result == 0) {
3641                 ldap_memfree(host);
3642 -               debug(LOGOPT_NONE, "sasl bind with mechanism %s succeeded",
3643 +               debug(logopt, "sasl bind with mechanism %s succeeded",
3644                       chosen_mech);
3645                 return conn;
3646         }
3647
3648 -       info(LOGOPT_ANY, "sasl bind with mechanism %s failed", mech);
3649 +       info(logopt, "sasl bind with mechanism %s failed", mech);
3650
3651         /* sasl bind failed */
3652         ldap_memfree(host);
3653 @@ -629,14 +629,14 @@ sasl_bind_mech(LDAP *ldap, struct lookup_context *ctxt, const char *mech)
3654   *  -1 on error or if no mechanism is supported by both client and server.
3655   */
3656  sasl_conn_t *
3657 -sasl_choose_mech(LDAP *ldap, struct lookup_context *ctxt)
3658 +sasl_choose_mech(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
3659  {
3660         sasl_conn_t *conn;
3661         int authenticated;
3662         int i;
3663         char **mechanisms;
3664
3665 -       mechanisms = get_server_SASL_mechanisms(ldap);
3666 +       mechanisms = get_server_SASL_mechanisms(logopt, ldap);
3667         if (!mechanisms)
3668                 return NULL;
3669
3670 @@ -652,12 +652,11 @@ sasl_choose_mech(LDAP *ldap, struct lookup_context *ctxt)
3671                 if (authtype_requires_creds(mechanisms[i]))
3672                         continue;
3673
3674 -               conn = sasl_bind_mech(ldap, ctxt, mechanisms[i]);
3675 +               conn = sasl_bind_mech(logopt, ldap, ctxt, mechanisms[i]);
3676                 if (conn) {
3677                         ctxt->sasl_mech = strdup(mechanisms[i]);
3678                         if (!ctxt->sasl_mech) {
3679 -                               crit(LOGOPT_ANY,
3680 -                                    "Successfully authenticated with "
3681 +                               crit(logopt, "Successfully authenticated with "
3682                                      "mechanism %s, but failed to allocate "
3683                                      "memory to hold the mechanism type.",
3684                                      mechanisms[i]);
3685 @@ -668,11 +667,11 @@ sasl_choose_mech(LDAP *ldap, struct lookup_context *ctxt)
3686                         authenticated = 1;
3687                         break;
3688                 }
3689 -               debug(LOGOPT_NONE, "Failed to authenticate with mech %s",
3690 +               debug(logopt, "Failed to authenticate with mech %s",
3691                       mechanisms[i]);
3692         }
3693
3694 -       debug(LOGOPT_NONE, "authenticated: %d, sasl_mech: %s",
3695 +       debug(logopt, "authenticated: %d, sasl_mech: %s",
3696               authenticated, ctxt->sasl_mech);
3697
3698         ldap_value_free(mechanisms);
3699 @@ -680,14 +679,14 @@ sasl_choose_mech(LDAP *ldap, struct lookup_context *ctxt)
3700  }
3701
3702  int
3703 -autofs_sasl_bind(LDAP *ldap, struct lookup_context *ctxt)
3704 +autofs_sasl_bind(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
3705  {
3706         sasl_conn_t *conn;
3707
3708         if (!ctxt->sasl_mech)
3709                 return -1;
3710
3711 -       conn = sasl_bind_mech(ldap, ctxt, ctxt->sasl_mech);
3712 +       conn = sasl_bind_mech(logopt, ldap, ctxt, ctxt->sasl_mech);
3713         if (!conn)
3714                 return -1;
3715
3716 @@ -717,13 +716,13 @@ autofs_sasl_unbind(struct lookup_context *ctxt)
3717   * -1  -  Failure
3718   */
3719  int
3720 -autofs_sasl_init(LDAP *ldap, struct lookup_context *ctxt)
3721 +autofs_sasl_init(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
3722  {
3723         sasl_conn_t *conn;
3724
3725         /* Start up Cyrus SASL--only needs to be done once. */
3726         if (sasl_client_init(callbacks) != SASL_OK) {
3727 -               error(LOGOPT_ANY, "sasl_client_init failed");
3728 +               error(logopt, "sasl_client_init failed");
3729                 return -1;
3730         }
3731
3732 @@ -736,9 +735,9 @@ autofs_sasl_init(LDAP *ldap, struct lookup_context *ctxt)
3733          *  select one.
3734          */
3735         if (ctxt->sasl_mech)
3736 -               conn = sasl_bind_mech(ldap, ctxt, ctxt->sasl_mech);
3737 +               conn = sasl_bind_mech(logopt, ldap, ctxt, ctxt->sasl_mech);
3738         else
3739 -               conn = sasl_choose_mech(ldap, ctxt);
3740 +               conn = sasl_choose_mech(logopt, ldap, ctxt);
3741
3742         if (conn) {
3743                 sasl_dispose(&conn);
3744 @@ -772,8 +771,7 @@ autofs_sasl_done(struct lookup_context *ctxt)
3745                 else
3746                         ret = krb5_cc_destroy(ctxt->krb5ctxt, ctxt->krb5_ccache);
3747                 if (ret)
3748 -                       warn(LOGOPT_ANY,
3749 -                            "krb5_cc_destroy failed with non-fatal error %d",
3750 +                       logmsg("krb5_cc_destroy failed with non-fatal error %d",
3751                              ret);
3752
3753                 status = pthread_mutex_unlock(&krb5cc_mutex);
3754 @@ -782,8 +780,7 @@ autofs_sasl_done(struct lookup_context *ctxt)
3755
3756                 krb5_free_context(ctxt->krb5ctxt);
3757                 if (unsetenv(krb5ccenv) != 0)
3758 -                       warn(LOGOPT_ANY,
3759 -                            "unsetenv failed with error %d", errno);
3760 +                       logerr("unsetenv failed with error %d", errno);
3761
3762                 ctxt->krb5ctxt = NULL;
3763                 ctxt->krb5_ccache = NULL;
3764 diff --git a/modules/lookup_file.c b/modules/lookup_file.c
3765 index 31ee0fb..921b32b 100644
3766 --- a/modules/lookup_file.c
3767 +++ b/modules/lookup_file.c
3768 @@ -63,13 +63,13 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
3769         ctxt = malloc(sizeof(struct lookup_context));
3770         if (!ctxt) {
3771                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
3772 -               crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
3773 +               logerr(MODPREFIX "malloc: %s", estr);
3774                 return 1;
3775         }
3776
3777         if (argc < 1) {
3778                 free(ctxt);
3779 -               crit(LOGOPT_ANY, MODPREFIX "No map name");
3780 +               logerr(MODPREFIX "No map name");
3781                 return 1;
3782         }
3783
3784 @@ -77,21 +77,21 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
3785
3786         if (ctxt->mapname[0] != '/') {
3787                 free(ctxt);
3788 -               msg(MODPREFIX "file map %s is not an absolute pathname",
3789 -                   argv[0]);
3790 +               logmsg(MODPREFIX
3791 +                    "file map %s is not an absolute pathname", argv[0]);
3792                 return 1;
3793         }
3794
3795         if (access(ctxt->mapname, R_OK)) {
3796                 free(ctxt);
3797 -               msg(MODPREFIX "file map %s missing or not readable",
3798 -                   argv[0]);
3799 +               warn(LOGOPT_NONE, MODPREFIX
3800 +                   "file map %s missing or not readable", argv[0]);
3801                 return 1;
3802         }
3803
3804         if (stat(ctxt->mapname, &st)) {
3805                 free(ctxt);
3806 -               crit(LOGOPT_ANY, MODPREFIX "file map %s, could not stat",
3807 +               logmsg(MODPREFIX "file map %s, could not stat",
3808                      argv[0]);
3809                 return 1;
3810         }
3811 @@ -104,7 +104,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
3812         ctxt->parse = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
3813         if (!ctxt->parse) {
3814                 free(ctxt);
3815 -               crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
3816 +               logmsg(MODPREFIX "failed to open parse context");
3817                 return 1;
3818         }
3819         *context = ctxt;
3820 @@ -112,7 +112,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
3821         return 0;
3822  }
3823
3824 -static int read_one(FILE *f, char *key, unsigned int *k_len, char *mapent, unsigned int *m_len)
3825 +static int read_one(unsigned logopt, FILE *f, char *key, unsigned int *k_len, char *mapent, unsigned int *m_len)
3826  {
3827         char *kptr, *p;
3828         int mapent_len, key_len;
3829 @@ -193,7 +193,7 @@ static int read_one(FILE *f, char *key, unsigned int *k_len, char *mapent, unsig
3830                                 if (gotten == got_plus)
3831                                         goto got_it;
3832                                 else if (escape == esc_all) {
3833 -                                       warn(LOGOPT_ANY, MODPREFIX
3834 +                                       warn(logopt, MODPREFIX
3835                                             "unmatched \" in map key %s", key);
3836                                         goto next;
3837                                 } else if (escape != esc_val)
3838 @@ -208,7 +208,7 @@ static int read_one(FILE *f, char *key, unsigned int *k_len, char *mapent, unsig
3839                                 if (key_len == KEY_MAX_LEN) {
3840                                         state = st_badent;
3841                                         gotten = got_nothing;
3842 -                                       warn(LOGOPT_ANY,
3843 +                                       warn(logopt,
3844                                               MODPREFIX "map key \"%s...\" "
3845                                               "is too long.  The maximum key "
3846                                               "length is %d", key,
3847 @@ -245,7 +245,7 @@ static int read_one(FILE *f, char *key, unsigned int *k_len, char *mapent, unsig
3848                                 state = st_begin;
3849                                 if (gotten == got_real || gotten == getting)
3850                                         goto got_it;
3851 -                               warn(LOGOPT_ANY, MODPREFIX
3852 +                               warn(logopt, MODPREFIX
3853                                       "bad map entry \"%s...\" for key "
3854                                       "\"%s\"", mapent, key);
3855                                 goto next;
3856 @@ -286,7 +286,7 @@ static int read_one(FILE *f, char *key, unsigned int *k_len, char *mapent, unsig
3857                         if (ch == '\n') {
3858                                 if (escape == esc_all) {
3859                                         state = st_begin;
3860 -                                       warn(LOGOPT_ANY, MODPREFIX
3861 +                                       warn(logopt, MODPREFIX
3862                                              "unmatched \" in %s for key %s",
3863                                              mapent, key);
3864                                         goto next;
3865 @@ -310,7 +310,7 @@ static int read_one(FILE *f, char *key, unsigned int *k_len, char *mapent, unsig
3866                                         goto got_it;
3867                                 ungetc(nch, f);
3868                         } else {
3869 -                               warn(LOGOPT_ANY,
3870 +                               warn(logopt,
3871                                       MODPREFIX "map entry \"%s...\" for key "
3872                                       "\"%s\" is too long.  The maximum entry"
3873                                       " size is %d", mapent, key,
3874 @@ -388,6 +388,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
3875         struct lookup_context *ctxt = (struct lookup_context *) context;
3876         unsigned int timeout = master->default_timeout;
3877         unsigned int logging = master->default_logging;
3878 +       unsigned int logopt = master->logopt;
3879         char *buffer;
3880         int blen;
3881         char *path;
3882 @@ -402,29 +403,28 @@ int lookup_read_master(struct master *master, time_t age, void *context)
3883                 return NSS_STATUS_UNAVAIL;
3884
3885         if (master->depth > MAX_INCLUDE_DEPTH) {
3886 -               error(LOGOPT_ANY,
3887 -                     MODPREFIX
3888 +               error(logopt, MODPREFIX
3889                       "maximum include depth exceeded %s", master->name);
3890                 return NSS_STATUS_UNAVAIL;
3891         }
3892
3893         path = alloca(KEY_MAX_LEN + 1);
3894         if (!path) {
3895 -               error(LOGOPT_ANY,
3896 +               error(logopt,
3897                       MODPREFIX "could not malloc storage for path");
3898                 return NSS_STATUS_UNAVAIL;
3899         }
3900
3901         ent = alloca(MAPENT_MAX_LEN + 1);
3902         if (!ent) {
3903 -               error(LOGOPT_ANY,
3904 +               error(logopt,
3905                       MODPREFIX "could not malloc storage for mapent");
3906                 return NSS_STATUS_UNAVAIL;
3907         }
3908
3909         f = fopen(ctxt->mapname, "r");
3910         if (!f) {
3911 -               error(LOGOPT_ANY,
3912 +               error(logopt,
3913                       MODPREFIX "could not open master map file %s",
3914                       ctxt->mapname);
3915                 return NSS_STATUS_UNAVAIL;
3916 @@ -438,19 +438,19 @@ int lookup_read_master(struct master *master, time_t age, void *context)
3917         }
3918
3919         while(1) {
3920 -               entry = read_one(f, path, &path_len, ent, &ent_len);
3921 +               entry = read_one(logopt, f, path, &path_len, ent, &ent_len);
3922                 if (!entry) {
3923                         if (feof(f))
3924                                 break;
3925                         if (ferror(f)) {
3926 -                               warn(LOGOPT_ANY, MODPREFIX
3927 +                               warn(logopt, MODPREFIX
3928                                      "error reading map %s", ctxt->mapname);
3929                                 break;
3930                         }
3931                         continue;
3932                 }
3933
3934 -               debug(LOGOPT_NONE, MODPREFIX "read entry %s", path);
3935 +               debug(logopt, MODPREFIX "read entry %s", path);
3936
3937                 /*
3938                  * If key starts with '+' it has to be an
3939 @@ -470,7 +470,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
3940                         master->depth++;
3941                         status = lookup_nss_read_master(master, age);
3942                         if (!status)
3943 -                               warn(LOGOPT_ANY,
3944 +                               warn(logopt,
3945                                      MODPREFIX
3946                                      "failed to read included master map %s",
3947                                      master->name);
3948 @@ -482,7 +482,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
3949                         blen = path_len + 1 + ent_len + 1;
3950                         buffer = malloc(blen);
3951                         if (!buffer) {
3952 -                               error(LOGOPT_ANY,
3953 +                               error(logopt,
3954                                       MODPREFIX "could not malloc parse buffer");
3955                                 return NSS_STATUS_UNAVAIL;
3956                         }
3957 @@ -503,7 +503,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
3958         }
3959
3960         if (fstat(fd, &st)) {
3961 -               crit(LOGOPT_ANY, MODPREFIX "file map %s, could not stat",
3962 +               crit(logopt, MODPREFIX "file map %s, could not stat",
3963                        ctxt->mapname);
3964                 return NSS_STATUS_UNAVAIL;
3965         }
3966 @@ -684,12 +684,12 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
3967         }
3968
3969         while(1) {
3970 -               entry = read_one(f, key, &k_len, mapent, &m_len);
3971 +               entry = read_one(ap->logopt, f, key, &k_len, mapent, &m_len);
3972                 if (!entry) {
3973                         if (feof(f))
3974                                 break;
3975                         if (ferror(f)) {
3976 -                               warn(LOGOPT_ANY, MODPREFIX
3977 +                               warn(ap->logopt, MODPREFIX
3978                                       "error reading map %s", ctxt->mapname);
3979                                 break;
3980                         }
3981 @@ -791,7 +791,7 @@ static int lookup_one(struct autofs_point *ap,
3982         }
3983
3984         while(1) {
3985 -               entry = read_one(f, mkey, &k_len, mapent, &m_len);
3986 +               entry = read_one(ap->logopt, f, mkey, &k_len, mapent, &m_len);
3987                 if (entry) {
3988                         /*
3989                          * If key starts with '+' it has to be an
3990 @@ -860,7 +860,7 @@ static int lookup_one(struct autofs_point *ap,
3991                         break;
3992
3993                 if (ferror(f)) {
3994 -                       warn(LOGOPT_ANY, MODPREFIX
3995 +                       warn(ap->logopt, MODPREFIX
3996                               "error reading map %s", ctxt->mapname);
3997                         break;
3998                 }
3999 @@ -904,7 +904,7 @@ static int lookup_wild(struct autofs_point *ap, struct lookup_context *ctxt)
4000         }
4001
4002         while(1) {
4003 -               entry = read_one(f, mkey, &k_len, mapent, &m_len);
4004 +               entry = read_one(ap->logopt, f, mkey, &k_len, mapent, &m_len);
4005                 if (entry) {
4006                         int eq;
4007
4008 @@ -925,7 +925,7 @@ static int lookup_wild(struct autofs_point *ap, struct lookup_context *ctxt)
4009                         break;
4010
4011                 if (ferror(f)) {
4012 -                       warn(LOGOPT_ANY, MODPREFIX
4013 +                       warn(ap->logopt, MODPREFIX
4014                               "error reading map %s", ctxt->mapname);
4015                         break;
4016                 }
4017 diff --git a/modules/lookup_hesiod.c b/modules/lookup_hesiod.c
4018 index f30e9b2..649e24c 100644
4019 --- a/modules/lookup_hesiod.c
4020 +++ b/modules/lookup_hesiod.c
4021 @@ -48,7 +48,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4022         ctxt = malloc(sizeof(struct lookup_context));
4023         if (!ctxt) {
4024                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
4025 -               crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4026 +               logerr(MODPREFIX "malloc: %s", estr);
4027                 return 1;
4028         }
4029
4030 @@ -58,7 +58,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4031         /* Initialize the hesiod context. */
4032         if (hesiod_init(&(ctxt->hesiod_context)) != 0) {
4033                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
4034 -               crit(LOGOPT_ANY, MODPREFIX "hesiod_init(): %s", estr);
4035 +               logerr(MODPREFIX "hesiod_init(): %s", estr);
4036                 free(ctxt);
4037                 return 1;
4038         }
4039 @@ -70,7 +70,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4040         /* Open the parser, if we can. */
4041         ctxt->parser = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
4042         if (!ctxt->parser) {
4043 -               crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
4044 +               logerr(MODPREFIX "failed to open parse context");
4045                 free(ctxt);
4046                 return 1;
4047         }
4048 diff --git a/modules/lookup_hosts.c b/modules/lookup_hosts.c
4049 index d711611..d746e42 100644
4050 --- a/modules/lookup_hosts.c
4051 +++ b/modules/lookup_hosts.c
4052 @@ -57,7 +57,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4053         ctxt = malloc(sizeof(struct lookup_context));
4054         if (!ctxt) {
4055                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
4056 -               crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4057 +               logerr(MODPREFIX "malloc: %s", estr);
4058                 return 1;
4059         }
4060
4061 @@ -65,7 +65,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4062
4063         ctxt->parse = open_parse(mapfmt, MODPREFIX, argc, argv);
4064         if (!ctxt->parse) {
4065 -               crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
4066 +               logerr(MODPREFIX "failed to open parse context");
4067                 free(ctxt);
4068                 return 1;
4069         }
4070 @@ -94,7 +94,7 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
4071
4072         status = pthread_mutex_lock(&hostent_mutex);
4073         if (status) {
4074 -               error(LOGOPT_ANY, MODPREFIX "failed to lock hostent mutex");
4075 +               error(ap->logopt, MODPREFIX "failed to lock hostent mutex");
4076                 return NSS_STATUS_UNAVAIL;
4077         }
4078
4079 @@ -110,7 +110,7 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
4080
4081         status = pthread_mutex_unlock(&hostent_mutex);
4082         if (status)
4083 -               error(LOGOPT_ANY, MODPREFIX "failed to unlock hostent mutex");
4084 +               error(ap->logopt, MODPREFIX "failed to unlock hostent mutex");
4085
4086         source->age = age;
4087
4088 @@ -157,10 +157,10 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
4089                 }
4090
4091                 if (*name == '/')
4092 -                       msg(MODPREFIX
4093 +                       info(ap->logopt, MODPREFIX
4094                               "can't find path in hosts map %s", name);
4095                 else
4096 -                       msg(MODPREFIX
4097 +                       info(ap->logopt, MODPREFIX
4098                               "can't find path in hosts map %s/%s",
4099                               ap->path, name);
4100
4101 @@ -216,7 +216,7 @@ done:
4102                         if (!mapent) {
4103                                 char *estr;
4104                                 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4105 -                               crit(ap->logopt, MODPREFIX "malloc: %s", estr);
4106 +                               logerr(MODPREFIX "malloc: %s", estr);
4107                                 rpc_exports_free(exp);
4108                                 return NSS_STATUS_UNAVAIL;
4109                         }
4110 @@ -230,7 +230,7 @@ done:
4111                         if (!mapent) {
4112                                 char *estr;
4113                                 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4114 -                               crit(ap->logopt, MODPREFIX "malloc: %s", estr);
4115 +                               logerr(MODPREFIX "malloc: %s", estr);
4116                                 rpc_exports_free(exp);
4117                                 return NSS_STATUS_UNAVAIL;
4118                         }
4119 diff --git a/modules/lookup_ldap.c b/modules/lookup_ldap.c
4120 index c0f228b..00215af 100644
4121 --- a/modules/lookup_ldap.c
4122 +++ b/modules/lookup_ldap.c
4123 @@ -49,9 +49,9 @@ static struct ldap_schema common_schema[] = {
4124  };
4125  static unsigned int common_schema_count = sizeof(common_schema)/sizeof(struct ldap_schema);
4126
4127 -static LDAP *auth_init(const char *, struct lookup_context *);
4128 +static LDAP *auth_init(unsigned logopt, const char *, struct lookup_context *);
4129
4130 -int bind_ldap_anonymous(LDAP *ldap, struct lookup_context *ctxt)
4131 +int bind_ldap_anonymous(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
4132  {
4133         int rv;
4134
4135 @@ -62,15 +62,14 @@ int bind_ldap_anonymous(LDAP *ldap, struct lookup_context *ctxt)
4136
4137         if (rv != LDAP_SUCCESS) {
4138                 if (!ctxt->uri) {
4139 -                       crit(LOGOPT_ANY,
4140 -                            MODPREFIX "Unable to bind to the LDAP server: "
4141 +                       crit(logopt, MODPREFIX
4142 +                            "Unable to bind to the LDAP server: "
4143                              "%s, error %s", ctxt->server ? "" : "(default)",
4144                              ldap_err2string(rv));
4145                 } else {
4146                         struct ldap_uri *uri;
4147                         uri = list_entry(ctxt->uri->next, struct ldap_uri, list);
4148 -                       warn(LOGOPT_ANY,
4149 -                            MODPREFIX "Unable to bind to the LDAP server: "
4150 +                       info(logopt, MODPREFIX "Unable to bind to the LDAP server: "
4151                              "%s, error %s", uri->uri, ldap_err2string(rv));
4152                 }
4153                 return -1;
4154 @@ -79,12 +78,11 @@ int bind_ldap_anonymous(LDAP *ldap, struct lookup_context *ctxt)
4155         return 0;
4156  }
4157
4158 -int unbind_ldap_connection(LDAP *ldap, struct lookup_context *ctxt)
4159 +int unbind_ldap_connection(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
4160  {
4161         int rv;
4162
4163  #ifdef WITH_SASL
4164 -       debug(LOGOPT_NONE, "use_tls: %d", ctxt->use_tls);
4165         /*
4166          * The OpenSSL library can't handle having its message and error
4167          * string database loaded multiple times and segfaults if the
4168 @@ -102,13 +100,12 @@ int unbind_ldap_connection(LDAP *ldap, struct lookup_context *ctxt)
4169
4170         rv = ldap_unbind_ext(ldap, NULL, NULL);
4171         if (rv != LDAP_SUCCESS)
4172 -               error(LOGOPT_ANY,
4173 -                    "unbind failed: %s", ldap_err2string(rv));
4174 +               error(logopt, "unbind failed: %s", ldap_err2string(rv));
4175
4176         return rv;
4177  }
4178
4179 -LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4180 +LDAP *init_ldap_connection(unsigned logopt, const char *uri, struct lookup_context *ctxt)
4181  {
4182         LDAP *ldap = NULL;
4183         struct timeval timeout     = { ctxt->timeout, 0 };
4184 @@ -120,9 +117,9 @@ LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4185         /* Initialize the LDAP context. */
4186         rv = ldap_initialize(&ldap, uri);
4187         if (rv != LDAP_OPT_SUCCESS) {
4188 -               crit(LOGOPT_ANY,
4189 -                    MODPREFIX "couldn't initialize LDAP connection to %s",
4190 -                    uri ? uri : "default server");
4191 +               info(logopt, MODPREFIX
4192 +                    "couldn't initialize LDAP connection to %s",
4193 +                    uri ? uri : "default");
4194                 return NULL;
4195         }
4196
4197 @@ -133,7 +130,7 @@ LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4198                 ldap_unbind_ext(ldap, NULL, NULL);
4199                 rv = ldap_initialize(&ldap, uri);
4200                 if (rv != LDAP_OPT_SUCCESS) {
4201 -                       crit(LOGOPT_ANY, MODPREFIX "couldn't initialize LDAP");
4202 +                       crit(logopt, MODPREFIX "couldn't initialize LDAP");
4203                         return NULL;
4204                 }
4205                 ctxt->version = 2;
4206 @@ -144,7 +141,7 @@ LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4207                 /* Set synchronous call timeout */
4208                 rv = ldap_set_option(ldap, LDAP_OPT_TIMEOUT, &timeout);
4209                 if (rv != LDAP_OPT_SUCCESS)
4210 -                       info(LOGOPT_ANY, MODPREFIX
4211 +                       info(logopt, MODPREFIX
4212                              "failed to set synchronous call timeout to %d",
4213                              timeout.tv_sec);
4214         }
4215 @@ -152,16 +149,14 @@ LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4216         /* Sane network timeout */
4217         rv = ldap_set_option(ldap, LDAP_OPT_NETWORK_TIMEOUT, &net_timeout);
4218         if (rv != LDAP_OPT_SUCCESS)
4219 -               info(LOGOPT_ANY,
4220 -                    MODPREFIX "failed to set connection timeout to %d",
4221 +               info(logopt, MODPREFIX "failed to set connection timeout to %d",
4222                      net_timeout.tv_sec);
4223
4224  #ifdef WITH_SASL
4225         if (ctxt->use_tls) {
4226                 if (ctxt->version == 2) {
4227                         if (ctxt->tls_required) {
4228 -                               error(LOGOPT_ANY,
4229 -                                   MODPREFIX
4230 +                               error(logopt, MODPREFIX
4231                                     "TLS required but connection is version 2");
4232                                 ldap_unbind_ext(ldap, NULL, NULL);
4233                                 return NULL;
4234 @@ -171,16 +166,15 @@ LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4235
4236                 rv = ldap_start_tls_s(ldap, NULL, NULL);
4237                 if (rv != LDAP_SUCCESS) {
4238 -                       unbind_ldap_connection(ldap, ctxt);
4239 +                       unbind_ldap_connection(logopt, ldap, ctxt);
4240                         if (ctxt->tls_required) {
4241 -                               error(LOGOPT_ANY,
4242 -                                     MODPREFIX
4243 +                               error(logopt, MODPREFIX
4244                                       "TLS required but START_TLS failed: %s",
4245                                       ldap_err2string(rv));
4246                                 return NULL;
4247                         }
4248                         ctxt->use_tls = LDAP_TLS_DONT_USE;
4249 -                       ldap = init_ldap_connection(uri, ctxt);
4250 +                       ldap = init_ldap_connection(logopt, uri, ctxt);
4251                         if (ldap)
4252                                 ctxt->use_tls = LDAP_TLS_INIT;
4253                         return ldap;
4254 @@ -192,7 +186,7 @@ LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4255         return ldap;
4256  }
4257
4258 -static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *class, const char *key)
4259 +static int get_query_dn(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt, const char *class, const char *key)
4260  {
4261         char buf[PARSE_MAX_BUF];
4262         char *query, *dn, *qdn;
4263 @@ -206,7 +200,7 @@ static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *cla
4264         attrs[1] = NULL;
4265
4266         if (!ctxt->mapname && !ctxt->base) {
4267 -               error(LOGOPT_ANY, MODPREFIX "no master map to lookup");
4268 +               error(logopt, MODPREFIX "no master map to lookup");
4269                 return 0;
4270         }
4271
4272 @@ -218,7 +212,7 @@ static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *cla
4273         query = alloca(l);
4274         if (query == NULL) {
4275                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
4276 -               crit(LOGOPT_ANY, MODPREFIX "alloca: %s", estr);
4277 +               crit(logopt, MODPREFIX "alloca: %s", estr);
4278                 return NSS_STATUS_UNAVAIL;
4279         }
4280
4281 @@ -229,14 +223,14 @@ static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *cla
4282         if (ctxt->mapname) {
4283                 if (sprintf(query, "(&(objectclass=%s)(%s=%.*s))", class,
4284                      key, (int) strlen(ctxt->mapname), ctxt->mapname) >= l) {
4285 -                       debug(LOGOPT_NONE,
4286 +                       debug(logopt,
4287                               MODPREFIX "error forming query string");
4288                         return 0;
4289                 }
4290                 scope = LDAP_SCOPE_SUBTREE;
4291         } else {
4292                 if (sprintf(query, "(objectclass=%s)", class) >= l) {
4293 -                       debug(LOGOPT_NONE,
4294 +                       debug(logopt,
4295                               MODPREFIX "error forming query string");
4296                         return 0;
4297                 }
4298 @@ -259,15 +253,14 @@ static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *cla
4299         else {
4300                 struct ldap_searchdn *this = ctxt->sdns;
4301
4302 -               debug(LOGOPT_NONE, MODPREFIX
4303 -                             "check search base list");
4304 +               debug(logopt, MODPREFIX "check search base list");
4305
4306                 while (this) {
4307                         rv = ldap_search_s(ldap, this->basedn,
4308                                            scope, query, attrs, 0, &result);
4309
4310                         if ((rv == LDAP_SUCCESS) && result) {
4311 -                               debug(LOGOPT_NONE, MODPREFIX
4312 +                               debug(logopt, MODPREFIX
4313                                       "found search base under %s",
4314                                       this->basedn);
4315                                 break;
4316 @@ -283,7 +276,7 @@ static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *cla
4317         }
4318
4319         if ((rv != LDAP_SUCCESS) || !result) {
4320 -               error(LOGOPT_NONE,
4321 +               error(logopt,
4322                       MODPREFIX "query failed for %s: %s",
4323                       query, ldap_err2string(rv));
4324                 return 0;
4325 @@ -292,9 +285,9 @@ static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *cla
4326         e = ldap_first_entry(ldap, result);
4327         if (e) {
4328                 dn = ldap_get_dn(ldap, e);
4329 -               debug(LOGOPT_NONE, MODPREFIX "found query dn %s", dn);
4330 +               debug(logopt, MODPREFIX "found query dn %s", dn);
4331         } else {
4332 -               debug(LOGOPT_NONE,
4333 +               debug(logopt,
4334                       MODPREFIX "query succeeded, no matches for %s",
4335                       query);
4336                 ldap_msgfree(result);
4337 @@ -373,7 +366,7 @@ static struct ldap_schema *alloc_common_schema(struct ldap_schema *s)
4338         return schema;
4339  }
4340
4341 -static int find_query_dn(LDAP *ldap, struct lookup_context *ctxt)
4342 +static int find_query_dn(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
4343  {
4344         struct ldap_schema *schema;
4345         unsigned int i;
4346 @@ -384,11 +377,10 @@ static int find_query_dn(LDAP *ldap, struct lookup_context *ctxt)
4347         for (i = 0; i < common_schema_count; i++) {
4348                 const char *class = common_schema[i].map_class;
4349                 const char *key = common_schema[i].map_attr;
4350 -               if (get_query_dn(ldap, ctxt, class, key)) {
4351 +               if (get_query_dn(logopt, ldap, ctxt, class, key)) {
4352                         schema = alloc_common_schema(&common_schema[i]);
4353                         if (!schema) {
4354 -                               error(LOGOPT_ANY,
4355 -                                     MODPREFIX "failed to allocate schema");
4356 +                               error(logopt, MODPREFIX "failed to allocate schema");
4357                                 return 0;
4358                         }
4359                         ctxt->schema = schema;
4360 @@ -399,28 +391,26 @@ static int find_query_dn(LDAP *ldap, struct lookup_context *ctxt)
4361         return 0;
4362  }
4363
4364 -static int do_bind(LDAP *ldap, struct lookup_context *ctxt)
4365 +static int do_bind(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
4366  {
4367         char *host = NULL, *nhost;
4368         int rv, need_base = 1;
4369
4370  #ifdef WITH_SASL
4371 -       debug(LOGOPT_NONE, "auth_required: %d, sasl_mech %s",
4372 +       debug(logopt, MODPREFIX "auth_required: %d, sasl_mech %s",
4373               ctxt->auth_required, ctxt->sasl_mech);
4374
4375         if (ctxt->sasl_mech ||
4376            (ctxt->auth_required & (LDAP_AUTH_REQUIRED|LDAP_AUTH_AUTODETECT))) {
4377 -               rv = autofs_sasl_bind(ldap, ctxt);
4378 -               debug(LOGOPT_NONE, MODPREFIX
4379 -                     "autofs_sasl_bind returned %d", rv);
4380 +               rv = autofs_sasl_bind(logopt, ldap, ctxt);
4381 +               debug(logopt, MODPREFIX "autofs_sasl_bind returned %d", rv);
4382         } else {
4383 -               rv = bind_ldap_anonymous(ldap, ctxt);
4384 -               debug(LOGOPT_NONE,
4385 -                     MODPREFIX "ldap anonymous bind returned %d", rv);
4386 +               rv = bind_ldap_anonymous(logopt, ldap, ctxt);
4387 +               debug(logopt, MODPREFIX "ldap anonymous bind returned %d", rv);
4388         }
4389  #else
4390 -       rv = bind_ldap_anonymous(ldap, ctxt);
4391 -       debug(LOGOPT_NONE, MODPREFIX "ldap anonymous bind returned %d", rv);
4392 +       rv = bind_ldap_anonymous(logopt, ldap, ctxt);
4393 +       debug(logopt, MODPREFIX "ldap anonymous bind returned %d", rv);
4394  #endif
4395
4396         if (rv != 0)
4397 @@ -428,13 +418,13 @@ static int do_bind(LDAP *ldap, struct lookup_context *ctxt)
4398
4399         rv = ldap_get_option(ldap, LDAP_OPT_HOST_NAME, &host);
4400          if (rv != LDAP_SUCCESS || !host) {
4401 -               debug(LOGOPT_ANY, "failed to get hostname for connection");
4402 +               debug(logopt, "failed to get hostname for connection");
4403                 return 0;
4404         }
4405
4406         nhost = strdup(host);
4407         if (!nhost) {
4408 -               debug(LOGOPT_ANY, "failed to alloc context for hostname");
4409 +               debug(logopt, "failed to alloc context for hostname");
4410                 return 0;
4411         }
4412         ldap_memfree(host);
4413 @@ -463,16 +453,16 @@ static int do_bind(LDAP *ldap, struct lookup_context *ctxt)
4414          * base dn for searches.
4415          */
4416         if (!ctxt->schema) {
4417 -               if (!find_query_dn(ldap, ctxt)) {
4418 -                       error(LOGOPT_ANY,
4419 -                             MODPREFIX "failed to find valid query dn");
4420 +               if (!find_query_dn(logopt, ldap, ctxt)) {
4421 +                       warn(logopt,
4422 +                             MODPREFIX "failed to find valid query dn");
4423                         return 0;
4424                 }
4425         } else {
4426                 const char *class = ctxt->schema->map_class;
4427                 const char *key = ctxt->schema->map_attr;
4428 -               if (!get_query_dn(ldap, ctxt, class, key)) {
4429 -                       error(LOGOPT_ANY, MODPREFIX "failed to get query dn");
4430 +               if (!get_query_dn(logopt, ldap, ctxt, class, key)) {
4431 +                       error(logopt, MODPREFIX "failed to get query dn");
4432                         return 0;
4433                 }
4434         }
4435 @@ -480,23 +470,23 @@ static int do_bind(LDAP *ldap, struct lookup_context *ctxt)
4436         return 1;
4437  }
4438
4439 -static LDAP *do_connect(const char *uri, struct lookup_context *ctxt)
4440 +static LDAP *do_connect(unsigned logopt, const char *uri, struct lookup_context *ctxt)
4441  {
4442         LDAP *ldap;
4443
4444 -       ldap = init_ldap_connection(uri, ctxt);
4445 +       ldap = init_ldap_connection(logopt, uri, ctxt);
4446         if (!ldap)
4447                 return NULL;
4448
4449 -       if (!do_bind(ldap, ctxt)) {
4450 -               unbind_ldap_connection(ldap, ctxt);
4451 +       if (!do_bind(logopt, ldap, ctxt)) {
4452 +               unbind_ldap_connection(logopt, ldap, ctxt);
4453                 return NULL;
4454         }
4455
4456         return ldap;
4457  }
4458
4459 -static LDAP *connect_to_server(const char *uri, struct lookup_context *ctxt)
4460 +static LDAP *connect_to_server(unsigned logopt, const char *uri, struct lookup_context *ctxt)
4461  {
4462         LDAP *ldap;
4463
4464 @@ -506,19 +496,19 @@ static LDAP *connect_to_server(const char *uri, struct lookup_context *ctxt)
4465          * authentication.
4466          */
4467         if (ctxt->auth_required & LDAP_AUTH_REQUIRED) {
4468 -               ldap = auth_init(uri, ctxt);
4469 +               ldap = auth_init(logopt, uri, ctxt);
4470                 if (!ldap && ctxt->auth_required & LDAP_AUTH_AUTODETECT)
4471 -                       warn(LOGOPT_NONE,
4472 +                       info(logopt,
4473                              "no authentication mechanisms auto detected.");
4474                 if (!ldap) {
4475 -                       error(LOGOPT_ANY, MODPREFIX
4476 +                       error(logopt, MODPREFIX
4477                               "cannot initialize authentication setup");
4478                         return NULL;
4479                 }
4480
4481 -               if (!do_bind(ldap, ctxt)) {
4482 -                       unbind_ldap_connection(ldap, ctxt);
4483 -                       error(LOGOPT_ANY, MODPREFIX "cannot bind to server");
4484 +               if (!do_bind(logopt, ldap, ctxt)) {
4485 +                       unbind_ldap_connection(logopt, ldap, ctxt);
4486 +                       error(logopt, MODPREFIX "cannot bind to server");
4487                         return NULL;
4488                 }
4489
4490 @@ -526,16 +516,18 @@ static LDAP *connect_to_server(const char *uri, struct lookup_context *ctxt)
4491         }
4492  #endif
4493
4494 -       ldap = do_connect(uri, ctxt);
4495 +       ldap = do_connect(logopt, uri, ctxt);
4496         if (!ldap) {
4497 -               error(LOGOPT_ANY, MODPREFIX "cannot connect to server");
4498 +               warn(logopt,
4499 +                    MODPREFIX "couldn't connect to server %s",
4500 +                    uri ? uri : "default");
4501                 return NULL;
4502         }
4503
4504         return ldap;
4505  }
4506
4507 -static LDAP *find_server(struct lookup_context *ctxt)
4508 +static LDAP *find_server(unsigned logopt, struct lookup_context *ctxt)
4509  {
4510         LDAP *ldap = NULL;
4511         struct ldap_uri *this;
4512 @@ -547,10 +539,9 @@ static LDAP *find_server(struct lookup_context *ctxt)
4513         while(p != ctxt->uri) {
4514                 this = list_entry(p, struct ldap_uri, list);
4515                 p = p->next;
4516 -               debug(LOGOPT_ANY, "check uri %s", this->uri);
4517 -               ldap = connect_to_server(this->uri, ctxt);
4518 +               ldap = connect_to_server(logopt, this->uri, ctxt);
4519                 if (ldap) {
4520 -                       debug(LOGOPT_ANY, "connexted to uri %s", this->uri);
4521 +                       info(logopt, "connected to uri %s", this->uri);
4522                         break;
4523                 }
4524                 list_del_init(&this->list);
4525 @@ -568,17 +559,17 @@ static LDAP *find_server(struct lookup_context *ctxt)
4526         return ldap;
4527  }
4528
4529 -static LDAP *do_reconnect(struct lookup_context *ctxt)
4530 +static LDAP *do_reconnect(unsigned logopt, struct lookup_context *ctxt)
4531  {
4532         LDAP *ldap;
4533
4534         if (ctxt->server || !ctxt->uri) {
4535 -               ldap = do_connect(ctxt->server, ctxt);
4536 +               ldap = do_connect(logopt, ctxt->server, ctxt);
4537                 return ldap;
4538         } else {
4539                 struct ldap_uri *this;
4540                 this = list_entry(ctxt->uri->next, struct ldap_uri, list);
4541 -               ldap = do_connect(this->uri, ctxt);
4542 +               ldap = do_connect(logopt, this->uri, ctxt);
4543                 if (ldap)
4544                         return ldap;
4545                 /* Failed to connect, put at end of list */
4546 @@ -589,15 +580,15 @@ static LDAP *do_reconnect(struct lookup_context *ctxt)
4547         autofs_sasl_done(ctxt);
4548
4549         /* Current server failed connect, try the rest */
4550 -       ldap = find_server(ctxt);
4551 +       ldap = find_server(logopt, ctxt);
4552         if (!ldap)
4553 -               error(LOGOPT_ANY, MODPREFIX "failed to find available server");
4554 +               error(logopt, MODPREFIX "failed to find available server");
4555
4556         return ldap;
4557  }
4558
4559  #ifdef WITH_SASL
4560 -int get_property(xmlNodePtr node, const char *prop, char **value)
4561 +int get_property(unsigned logopt, xmlNodePtr node, const char *prop, char **value)
4562  {
4563         xmlChar *ret;
4564         xmlChar *property = (xmlChar *) prop;
4565 @@ -608,8 +599,7 @@ int get_property(xmlNodePtr node, const char *prop, char **value)
4566         }
4567
4568         if (!(*value = strdup((char *) ret))) {
4569 -               error(LOGOPT_ANY,
4570 -                     MODPREFIX "strdup failed with %d", errno);
4571 +               logerr(MODPREFIX "strdup failed with %d", errno);
4572                 xmlFree(ret);
4573                 return -1;
4574         }
4575 @@ -645,7 +635,7 @@ int authtype_requires_creds(const char *authtype)
4576   *  then no further action is necessary.  If it is not, the caller is free
4577   *  to then use another method to determine how to connect to the server.
4578   */
4579 -int parse_ldap_config(struct lookup_context *ctxt)
4580 +int parse_ldap_config(unsigned logopt, struct lookup_context *ctxt)
4581  {
4582         int          ret = 0, fallback = 0;
4583         unsigned int auth_required = LDAP_AUTH_NOTREQUIRED;
4584 @@ -662,7 +652,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4585
4586         auth_conf = (char *) defaults_get_auth_conf_file();
4587         if (!auth_conf) {
4588 -               error(LOGOPT_ANY,
4589 +               error(logopt,
4590                       MODPREFIX "failed to get auth config file name.");
4591                 return 0;
4592         }
4593 @@ -687,7 +677,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4594                         ctxt->client_princ = NULL;
4595                         return 0;
4596                 }
4597 -               error(LOGOPT_ANY,
4598 +               error(logopt,
4599                       MODPREFIX "stat(2) failed with error %s.",
4600                       strerror(errno));
4601                 return 0;
4602 @@ -696,8 +686,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4603         if (!S_ISREG(st.st_mode) ||
4604             st.st_uid != 0 || st.st_gid != 0 ||
4605             (st.st_mode & 0x01ff) != 0600) {
4606 -               error(LOGOPT_ANY,
4607 -                     MODPREFIX
4608 +               error(logopt, MODPREFIX
4609                       "Configuration file %s exists, but is not usable. "
4610                       "Please make sure that it is owned by root, group "
4611                       "is root, and the mode is 0600.",
4612 @@ -708,30 +697,29 @@ int parse_ldap_config(struct lookup_context *ctxt)
4613         xmlInitParser();
4614         doc = xmlParseFile(auth_conf);
4615         if (!doc) {
4616 -               warn(LOGOPT_ANY,
4617 -                    MODPREFIX "xmlParseFile failed for %s.", auth_conf);
4618 +               error(logopt, MODPREFIX
4619 +                    "xmlParseFile failed for %s.", auth_conf);
4620                 goto out;
4621         }
4622
4623         root = xmlDocGetRootElement(doc);
4624         if (!root) {
4625 -               debug(LOGOPT_ANY,
4626 -                     MODPREFIX "empty xml document (%s).", auth_conf);
4627 +               debug(logopt, MODPREFIX
4628 +                     "empty xml document (%s).", auth_conf);
4629                 fallback = 1;
4630                 goto out;
4631         }
4632
4633         if (xmlStrcmp(root->name, (const xmlChar *)"autofs_ldap_sasl_conf")) {
4634 -               error(LOGOPT_ANY,
4635 -                     MODPREFIX
4636 +               error(logopt, MODPREFIX
4637                       "The root node of the XML document %s is not "
4638                       "autofs_ldap_sasl_conf.", auth_conf);
4639                 goto out;
4640         }
4641
4642 -       ret = get_property(root, "usetls", &usetls);
4643 +       ret = get_property(logopt, root, "usetls", &usetls);
4644         if (ret != 0) {
4645 -               error(LOGOPT_ANY,
4646 +               error(logopt,
4647                       MODPREFIX
4648                       "Failed read the usetls property from "
4649                       "the configuration file %s.", auth_conf);
4650 @@ -746,7 +734,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4651                 else if (!strcasecmp(usetls, "no"))
4652                         use_tls = LDAP_TLS_DONT_USE;
4653                 else {
4654 -                       error(LOGOPT_ANY,
4655 +                       error(logopt,
4656                               MODPREFIX
4657                               "The usetls property must have value "
4658                               "\"yes\" or \"no\".");
4659 @@ -756,9 +744,9 @@ int parse_ldap_config(struct lookup_context *ctxt)
4660                 free(usetls);
4661         }
4662
4663 -       ret = get_property(root, "tlsrequired", &tlsrequired);
4664 +       ret = get_property(logopt, root, "tlsrequired", &tlsrequired);
4665         if (ret != 0) {
4666 -               error(LOGOPT_ANY,
4667 +               error(logopt,
4668                       MODPREFIX
4669                       "Failed read the tlsrequired property from "
4670                       "the configuration file %s.", auth_conf);
4671 @@ -773,7 +761,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4672                 else if (!strcasecmp(tlsrequired, "no"))
4673                         tls_required = LDAP_TLS_DONT_USE;
4674                 else {
4675 -                       error(LOGOPT_ANY,
4676 +                       error(logopt,
4677                               MODPREFIX
4678                               "The tlsrequired property must have value "
4679                               "\"yes\" or \"no\".");
4680 @@ -783,9 +771,9 @@ int parse_ldap_config(struct lookup_context *ctxt)
4681                 free(tlsrequired);
4682         }
4683
4684 -       ret = get_property(root, "authrequired", &authrequired);
4685 +       ret = get_property(logopt, root, "authrequired", &authrequired);
4686         if (ret != 0) {
4687 -               error(LOGOPT_ANY,
4688 +               error(logopt,
4689                       MODPREFIX
4690                       "Failed read the authrequired property from "
4691                       "the configuration file %s.", auth_conf);
4692 @@ -802,7 +790,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4693                 else if (!strcasecmp(authrequired, "autodetect"))
4694                         auth_required = LDAP_AUTH_AUTODETECT;
4695                 else {
4696 -                       error(LOGOPT_ANY,
4697 +                       error(logopt,
4698                               MODPREFIX
4699                               "The authrequired property must have value "
4700                               "\"yes\", \"no\" or \"autodetect\".");
4701 @@ -812,9 +800,9 @@ int parse_ldap_config(struct lookup_context *ctxt)
4702                 free(authrequired);
4703         }
4704
4705 -       ret = get_property(root, "authtype", &authtype);
4706 +       ret = get_property(logopt, root, "authtype", &authtype);
4707         if (ret != 0) {
4708 -               error(LOGOPT_ANY,
4709 +               error(logopt,
4710                       MODPREFIX
4711                       "Failed read the authtype property from the "
4712                       "configuration file %s.", auth_conf);
4713 @@ -822,10 +810,10 @@ int parse_ldap_config(struct lookup_context *ctxt)
4714         }
4715
4716         if (authtype && authtype_requires_creds(authtype)) {
4717 -               ret = get_property(root, "user",  &user);
4718 -               ret |= get_property(root, "secret", &secret);
4719 +               ret = get_property(logopt, root, "user",  &user);
4720 +               ret |= get_property(logopt, root, "secret", &secret);
4721                 if (ret != 0 || (!user || !secret)) {
4722 -                       error(LOGOPT_ANY,
4723 +                       error(logopt,
4724                               MODPREFIX
4725                               "%s authentication type requires a username "
4726                               "and a secret.  Please fix your configuration "
4727 @@ -845,7 +833,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4728          * We allow the admin to specify the principal to use for the
4729          * client.  The default is "autofsclient/hostname@REALM".
4730          */
4731 -       (void)get_property(root, "clientprinc", &client_princ);
4732 +       (void)get_property(logopt, root, "clientprinc", &client_princ);
4733
4734         ctxt->auth_conf = auth_conf;
4735         ctxt->use_tls = use_tls;
4736 @@ -856,15 +844,15 @@ int parse_ldap_config(struct lookup_context *ctxt)
4737         ctxt->secret = secret;
4738         ctxt->client_princ = client_princ;
4739
4740 -       debug(LOGOPT_NONE,
4741 +       debug(logopt, MODPREFIX
4742               "ldap authentication configured with the following options:");
4743 -       debug(LOGOPT_NONE,
4744 +       debug(logopt, MODPREFIX
4745               "use_tls: %u, "
4746               "tls_required: %u, "
4747               "auth_required: %u, "
4748               "sasl_mech: %s",
4749               use_tls, tls_required, auth_required, authtype);
4750 -       debug(LOGOPT_NONE,
4751 +       debug(logopt, MODPREFIX
4752               "user: %s, "
4753               "secret: %s, "
4754               "client principal: %s",
4755 @@ -889,7 +877,7 @@ out:
4756   *  Returns ldap connection on success, with authtype, user and secret
4757   *  filled in as appropriate.  Returns NULL on failre.
4758   */
4759 -static LDAP *auth_init(const char *uri, struct lookup_context *ctxt)
4760 +static LDAP *auth_init(unsigned logopt, const char *uri, struct lookup_context *ctxt)
4761  {
4762         int ret;
4763         LDAP *ldap;
4764 @@ -900,11 +888,11 @@ static LDAP *auth_init(const char *uri, struct lookup_context *ctxt)
4765          *  if the permissions on the file were incorrect, or if the
4766          *  specified authentication type is not valid.
4767          */
4768 -       ret = parse_ldap_config(ctxt);
4769 +       ret = parse_ldap_config(logopt, ctxt);
4770         if (ret)
4771                 return NULL;
4772
4773 -       ldap = init_ldap_connection(uri, ctxt);
4774 +       ldap = init_ldap_connection(logopt, uri, ctxt);
4775         if (!ldap)
4776                 return NULL;
4777
4778 @@ -916,7 +904,7 @@ static LDAP *auth_init(const char *uri, struct lookup_context *ctxt)
4779          *  to use. If kerberos is used, it will also take care to initialize
4780          *  the credential cache and the client and service principals.
4781          */
4782 -       ret = autofs_sasl_init(ldap, ctxt);
4783 +       ret = autofs_sasl_init(logopt, ldap, ctxt);
4784         if (ret) {
4785                 ctxt->sasl_mech = NULL;
4786                 return NULL;
4787 @@ -930,7 +918,7 @@ static LDAP *auth_init(const char *uri, struct lookup_context *ctxt)
4788   *  Take an input string as specified in the master map, and break it
4789   *  down into a server name and basedn.
4790   */
4791 -static int parse_server_string(const char *url, struct lookup_context *ctxt)
4792 +static int parse_server_string(unsigned logopt, const char *url, struct lookup_context *ctxt)
4793  {
4794         char buf[MAX_ERR_BUF], *tmp = NULL, proto[9];
4795         const char *ptr, *name;
4796 @@ -939,8 +927,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4797         memset(proto, 0, 9);
4798         ptr = url;
4799
4800 -       debug(LOGOPT_NONE,
4801 -             MODPREFIX
4802 +       debug(logopt, MODPREFIX
4803               "Attempting to parse LDAP information from string \"%s\".", ptr);
4804
4805         ctxt->port = LDAP_PORT;
4806 @@ -974,7 +961,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4807                         if (!tmp) {
4808                                 char *estr;
4809                                 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4810 -                               crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4811 +                               logerr(MODPREFIX "malloc: %s", estr);
4812                                 return 0;
4813                         }
4814                         ctxt->server = tmp;
4815 @@ -987,7 +974,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4816                                 memcpy(ctxt->server, s, l);
4817                         ptr = q + 1;
4818                 } else {
4819 -                       crit(LOGOPT_ANY,
4820 +                       crit(logopt,
4821                              MODPREFIX "invalid LDAP map syntax %s", ptr);
4822                         return 0;
4823  /* TODO: why did I put this here, the parser shouldn't let this by
4824 @@ -996,7 +983,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4825                         if (!tmp) {
4826                                 char *estr;
4827                                 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4828 -                               crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4829 +                               crit(logopt, MODPREFIX "malloc: %s", estr);
4830                                 return 0;
4831                         }
4832                         ctxt->server = tmp;
4833 @@ -1014,7 +1001,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4834                                 q++;
4835
4836                 if (*q != ':') {
4837 -                       crit(LOGOPT_ANY,
4838 +                       crit(logopt,
4839                              MODPREFIX "invalid LDAP map syntax %s", ptr);
4840                         return 0;
4841                 }
4842 @@ -1031,7 +1018,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4843                 if (!tmp) {
4844                         char *estr;
4845                         estr = strerror_r(errno, buf, MAX_ERR_BUF);
4846 -                       crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4847 +                       logerr(MODPREFIX "malloc: %s", estr);
4848                         return 0;
4849                 }
4850                 ctxt->server = tmp;
4851 @@ -1072,7 +1059,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4852                         else {
4853                                 char *estr;
4854                                 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4855 -                               crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4856 +                               logerr(MODPREFIX "malloc: %s", estr);
4857                                 if (ctxt->server)
4858                                         free(ctxt->server);
4859                                 return 0;
4860 @@ -1083,7 +1070,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4861                         if (!base) {
4862                                 char *estr;
4863                                 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4864 -                               crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4865 +                               logerr(MODPREFIX "malloc: %s", estr);
4866                                 if (ctxt->server)
4867                                         free(ctxt->server);
4868                                 return 0;
4869 @@ -1097,7 +1084,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4870                 if (!map) {
4871                         char *estr;
4872                         estr = strerror_r(errno, buf, MAX_ERR_BUF);
4873 -                       crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4874 +                       logerr(MODPREFIX "malloc: %s", estr);
4875                         if (ctxt->server)
4876                                 free(ctxt->server);
4877                         return 0;
4878 @@ -1109,16 +1096,16 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4879
4880         if (!ctxt->server && *proto) {
4881                 if (!strncmp(proto, "ldaps", 5)) {
4882 -                       warn(LOGOPT_ANY, MODPREFIX
4883 +                       info(logopt, MODPREFIX
4884                              "server must be given to force ldaps, connection "
4885                              "will use LDAP client configured protocol");
4886                 }
4887         }
4888  done:
4889         if (ctxt->mapname)
4890 -               debug(LOGOPT_NONE, MODPREFIX "mapname %s", ctxt->mapname);
4891 +               debug(logopt, MODPREFIX "mapname %s", ctxt->mapname);
4892         else
4893 -               debug(LOGOPT_NONE, MODPREFIX "server \"%s\", base dn \"%s\"",
4894 +               debug(logopt, MODPREFIX "server \"%s\", base dn \"%s\"",
4895                         ctxt->server ? ctxt->server : "(default)",
4896                         ctxt->base);
4897
4898 @@ -1175,8 +1162,6 @@ static void validate_uris(struct list_head *list)
4899
4900                 /* At least we get some basic validation */
4901                 if (!ldap_is_ldap_url(this->uri)) {
4902 -                       warn(LOGOPT_ANY,
4903 -                            "removed invalid uri from list, %s", this->uri);
4904                         list_del(&this->list);
4905                         free(this->uri);
4906                         free(this);
4907 @@ -1202,7 +1187,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4908         ctxt = malloc(sizeof(struct lookup_context));
4909         if (!ctxt) {
4910                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
4911 -               crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4912 +               logerr(MODPREFIX "malloc: %s", estr);
4913                 return 1;
4914         }
4915         memset(ctxt, 0, sizeof(struct lookup_context));
4916 @@ -1215,7 +1200,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4917          * Parse out the server name and base dn, and fill them
4918          * into the proper places in the lookup context structure.
4919          */
4920 -       if (!parse_server_string(argv[0], ctxt)) {
4921 +       if (!parse_server_string(LOGOPT_NONE, argv[0], ctxt)) {
4922                 error(LOGOPT_ANY, MODPREFIX "cannot parse server string");
4923                 free_context(ctxt);
4924                 return 1;
4925 @@ -1236,13 +1221,13 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4926         }
4927
4928         if (ctxt->server || !ctxt->uri) {
4929 -               ldap = connect_to_server(ctxt->server, ctxt);
4930 +               ldap = connect_to_server(LOGOPT_NONE, ctxt->server, ctxt);
4931                 if (!ldap) {
4932                         free_context(ctxt);
4933                         return 1;
4934                 }
4935         } else {
4936 -               ldap = find_server(ctxt);
4937 +               ldap = find_server(LOGOPT_NONE, ctxt);
4938                 if (!ldap) {
4939                         free_context(ctxt);
4940                         error(LOGOPT_ANY, MODPREFIX
4941 @@ -1250,13 +1235,13 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4942                         return 1;
4943                 }
4944         }
4945 -       unbind_ldap_connection(ldap, ctxt);
4946 +       unbind_ldap_connection(LOGOPT_ANY, ldap, ctxt);
4947
4948         /* Open the parser, if we can. */
4949         ctxt->parse = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
4950         if (!ctxt->parse) {
4951                 free_context(ctxt);
4952 -               crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
4953 +               logerr(MODPREFIX "failed to open parse context");
4954                 return 1;
4955         }
4956         *context = ctxt;
4957 @@ -1269,6 +1254,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
4958         struct lookup_context *ctxt = (struct lookup_context *) context;
4959         unsigned int timeout = master->default_timeout;
4960         unsigned int logging = master->default_logging;
4961 +       unsigned int logopt = master->logopt;
4962         int rv, l, count, blen;
4963         char buf[PARSE_MAX_BUF];
4964         char *query;
4965 @@ -1293,45 +1279,44 @@ int lookup_read_master(struct master *master, time_t age, void *context)
4966         query = alloca(l);
4967         if (query == NULL) {
4968                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
4969 -               crit(LOGOPT_ANY, MODPREFIX "alloca: %s", estr);
4970 +               logerr(MODPREFIX "alloca: %s", estr);
4971                 return NSS_STATUS_UNAVAIL;
4972         }
4973
4974         if (sprintf(query, "(objectclass=%s)", class) >= l) {
4975 -               debug(LOGOPT_NONE, MODPREFIX "error forming query string");
4976 +               error(logopt, MODPREFIX "error forming query string");
4977                 return NSS_STATUS_UNAVAIL;
4978         }
4979         query[l] = '\0';
4980
4981         /* Initialize the LDAP context. */
4982 -       ldap = do_reconnect(ctxt);
4983 +       ldap = do_reconnect(logopt, ctxt);
4984         if (!ldap)
4985                 return NSS_STATUS_UNAVAIL;
4986
4987         /* Look around. */
4988 -       debug(LOGOPT_NONE,
4989 +       debug(logopt,
4990               MODPREFIX "searching for \"%s\" under \"%s\"", query, ctxt->qdn);
4991
4992         rv = ldap_search_s(ldap, ctxt->qdn, scope, query, attrs, 0, &result);
4993
4994         if ((rv != LDAP_SUCCESS) || !result) {
4995 -               error(LOGOPT_NONE,
4996 -                     MODPREFIX "query failed for %s: %s",
4997 +               error(logopt, MODPREFIX "query failed for %s: %s",
4998                       query, ldap_err2string(rv));
4999 -               unbind_ldap_connection(ldap, ctxt);
5000 +               unbind_ldap_connection(logging, ldap, ctxt);
5001                 return NSS_STATUS_NOTFOUND;
5002         }
5003
5004         e = ldap_first_entry(ldap, result);
5005         if (!e) {
5006 -               debug(LOGOPT_NONE,
5007 +               debug(logopt,
5008                       MODPREFIX "query succeeded, no matches for %s",
5009                       query);
5010                 ldap_msgfree(result);
5011 -               unbind_ldap_connection(ldap, ctxt);
5012 +               unbind_ldap_connection(logging, ldap, ctxt);
5013                 return NSS_STATUS_NOTFOUND;
5014         } else
5015 -               debug(LOGOPT_NONE, MODPREFIX "examining entries");
5016 +               debug(logopt, MODPREFIX "examining entries");
5017
5018         while (e) {
5019                 keyValue = ldap_get_values(ldap, e, entry);
5020 @@ -1346,7 +1331,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5021                  * each map entry
5022                  */
5023                 if (ldap_count_values(keyValue) > 1) {
5024 -                       error(LOGOPT_ANY,
5025 +                       error(logopt,
5026                               MODPREFIX
5027                               "key %s has duplicate entries - ignoring",
5028                               *keyValue);
5029 @@ -1358,7 +1343,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5030                  * inclusion is only valid in file maps.
5031                  */
5032                 if (**keyValue == '+') {
5033 -                       warn(LOGOPT_ANY,
5034 +                       warn(logopt,
5035                              MODPREFIX
5036                              "ignoreing '+' map entry - not in file map");
5037                         goto next;
5038 @@ -1366,7 +1351,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5039
5040                 values = ldap_get_values(ldap, e, info);
5041                 if (!values || !*values) {
5042 -                       debug(LOGOPT_NONE,
5043 +                       debug(logopt,
5044                               MODPREFIX "no %s defined for %s", info, query);
5045                         goto next;
5046                 }
5047 @@ -1376,7 +1361,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5048                  */
5049                 count = ldap_count_values(values);
5050                 if (count > 1) {
5051 -                       error(LOGOPT_ANY,
5052 +                       error(logopt,
5053                               MODPREFIX
5054                               "one value per key allowed in master map");
5055                         ldap_value_free(values);
5056 @@ -1385,7 +1370,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5057
5058                 blen = strlen(*keyValue) + 1 + strlen(*values) + 1;
5059                 if (blen > PARSE_MAX_BUF) {
5060 -                       error(LOGOPT_ANY, MODPREFIX "map entry too long");
5061 +                       error(logopt, MODPREFIX "map entry too long");
5062                         ldap_value_free(values);
5063                         goto next;
5064                 }
5065 @@ -1403,7 +1388,7 @@ next:
5066
5067         /* Clean up. */
5068         ldap_msgfree(result);
5069 -       unbind_ldap_connection(ldap, ctxt);
5070 +       unbind_ldap_connection(logopt, ldap, ctxt);
5071
5072         return NSS_STATUS_SUCCESS;
5073  }
5074 @@ -1445,7 +1430,7 @@ static int read_one_map(struct autofs_point *ap,
5075         query = alloca(l);
5076         if (query == NULL) {
5077                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5078 -               crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
5079 +               logerr(MODPREFIX "malloc: %s", estr);
5080                 return NSS_STATUS_UNAVAIL;
5081         }
5082
5083 @@ -1456,7 +1441,7 @@ static int read_one_map(struct autofs_point *ap,
5084         query[l] = '\0';
5085
5086         /* Initialize the LDAP context. */
5087 -       ldap = do_reconnect(ctxt);
5088 +       ldap = do_reconnect(ap->logopt, ctxt);
5089         if (!ldap)
5090                 return NSS_STATUS_UNAVAIL;
5091
5092 @@ -1470,7 +1455,7 @@ static int read_one_map(struct autofs_point *ap,
5093                 debug(ap->logopt,
5094                       MODPREFIX "query failed for %s: %s",
5095                       query, ldap_err2string(rv));
5096 -               unbind_ldap_connection(ldap, ctxt);
5097 +               unbind_ldap_connection(ap->logopt, ldap, ctxt);
5098                 *result_ldap = rv;
5099                 return NSS_STATUS_NOTFOUND;
5100         }
5101 @@ -1480,7 +1465,7 @@ static int read_one_map(struct autofs_point *ap,
5102                 debug(ap->logopt,
5103                       MODPREFIX "query succeeded, no matches for %s", query);
5104                 ldap_msgfree(result);
5105 -               unbind_ldap_connection(ldap, ctxt);
5106 +               unbind_ldap_connection(ap->logopt, ldap, ctxt);
5107                 return NSS_STATUS_NOTFOUND;
5108         } else
5109                 debug(ap->logopt, MODPREFIX "examining entries");
5110 @@ -1612,8 +1597,7 @@ static int read_one_map(struct autofs_point *ap,
5111                                 if (!mapent) {
5112                                         char *estr;
5113                                         estr = strerror_r(errno, buf, MAX_ERR_BUF);
5114 -                                       error(ap->logopt,
5115 -                                             MODPREFIX "malloc: %s", estr);
5116 +                                       logerr(MODPREFIX "malloc: %s", estr);
5117                                         ldap_value_free_len(bvValues);
5118                                         goto next;
5119                                 }
5120 @@ -1633,8 +1617,7 @@ static int read_one_map(struct autofs_point *ap,
5121                                 } else {
5122                                         char *estr;
5123                                         estr = strerror_r(errno, buf, MAX_ERR_BUF);
5124 -                                       error(ap->logopt,
5125 -                                             MODPREFIX "realloc: %s", estr);
5126 +                                       logerr(MODPREFIX "realloc: %s", estr);
5127                                 }
5128                         }
5129                 }
5130 @@ -1669,7 +1652,7 @@ next:
5131
5132         /* Clean up. */
5133         ldap_msgfree(result);
5134 -       unbind_ldap_connection(ldap, ctxt);
5135 +       unbind_ldap_connection(ap->logopt, ldap, ctxt);
5136
5137         source->age = age;
5138
5139 @@ -1766,7 +1749,7 @@ static int lookup_one(struct autofs_point *ap,
5140         query[ql] = '\0';
5141
5142         /* Initialize the LDAP context. */
5143 -       ldap = do_reconnect(ctxt);
5144 +       ldap = do_reconnect(ap->logopt, ctxt);
5145         if (!ldap)
5146                 return CHE_FAIL;
5147
5148 @@ -1777,7 +1760,7 @@ static int lookup_one(struct autofs_point *ap,
5149
5150         if ((rv != LDAP_SUCCESS) || !result) {
5151                 crit(ap->logopt, MODPREFIX "query failed for %s", query);
5152 -               unbind_ldap_connection(ldap, ctxt);
5153 +               unbind_ldap_connection(ap->logopt, ldap, ctxt);
5154                 return CHE_FAIL;
5155         }
5156
5157 @@ -1789,7 +1772,7 @@ static int lookup_one(struct autofs_point *ap,
5158                 debug(ap->logopt,
5159                      MODPREFIX "got answer, but no entry for %s", query);
5160                 ldap_msgfree(result);
5161 -               unbind_ldap_connection(ldap, ctxt);
5162 +               unbind_ldap_connection(ap->logopt, ldap, ctxt);
5163                 return CHE_MISSING;
5164         }
5165
5166 @@ -1897,8 +1880,7 @@ static int lookup_one(struct autofs_point *ap,
5167                                 if (!mapent) {
5168                                         char *estr;
5169                                         estr = strerror_r(errno, buf, MAX_ERR_BUF);
5170 -                                       error(ap->logopt,
5171 -                                             MODPREFIX "malloc: %s", estr);
5172 +                                       logerr(MODPREFIX "malloc: %s", estr);
5173                                         ldap_value_free_len(bvValues);
5174                                         goto next;
5175                                 }
5176 @@ -1918,8 +1900,7 @@ static int lookup_one(struct autofs_point *ap,
5177                                 } else {
5178                                         char *estr;
5179                                         estr = strerror_r(errno, buf, MAX_ERR_BUF);
5180 -                                       error(ap->logopt,
5181 -                                             MODPREFIX "realloc: %s", estr);
5182 +                                       logerr(MODPREFIX "realloc: %s", estr);
5183                                 }
5184                         }
5185                 }
5186 @@ -1955,7 +1936,7 @@ next:
5187         }
5188
5189         ldap_msgfree(result);
5190 -       unbind_ldap_connection(ldap, ctxt);
5191 +       unbind_ldap_connection(ap->logopt, ldap, ctxt);
5192
5193         /* Failed to find wild entry, update cache if needed */
5194         pthread_cleanup_push(cache_lock_cleanup, mc);
5195 diff --git a/modules/lookup_multi.c b/modules/lookup_multi.c
5196 index 8fa94ae..601d48e 100644
5197 --- a/modules/lookup_multi.c
5198 +++ b/modules/lookup_multi.c
5199 @@ -73,7 +73,7 @@ static struct lookup_mod *nss_open_lookup(const char *format, int argc, const ch
5200         if (nsswitch_parse(&nsslist)) {
5201                 if (!list_empty(&nsslist))
5202                         free_sources(&nsslist);
5203 -               error(LOGOPT_ANY, "can't to read name service switch config.");
5204 +               logerr("can't to read name service switch config.");
5205                 return NULL;
5206         }
5207
5208 @@ -92,7 +92,7 @@ static struct lookup_mod *nss_open_lookup(const char *format, int argc, const ch
5209                         path = malloc(strlen(AUTOFS_MAP_DIR) + strlen(argv[0]) + 2);
5210                         if (!path) {
5211                                 estr = strerror_r(errno, buf, MAX_ERR_BUF);
5212 -                               crit(LOGOPT_ANY, MODPREFIX "error: %s", estr);
5213 +                               logerr(MODPREFIX "error: %s", estr);
5214                                 free_sources(&nsslist);
5215                                 return NULL;
5216                         }
5217 @@ -150,7 +150,7 @@ int lookup_init(const char *my_mapfmt, int argc, const char *const *argv, void *
5218         memset(ctxt, 0, sizeof(struct lookup_context));
5219
5220         if (argc < 1) {
5221 -               crit(LOGOPT_ANY, MODPREFIX "No map list");
5222 +               logerr(MODPREFIX "No map list");
5223                 goto error_out;
5224         }
5225
5226 @@ -176,8 +176,7 @@ int lookup_init(const char *my_mapfmt, int argc, const char *const *argv, void *
5227                 if (!strcmp(ctxt->argl[an], "--")) {
5228                         ctxt->argl[an] = NULL;
5229                         if (!args) {
5230 -                               crit(LOGOPT_ANY,
5231 -                                    MODPREFIX "error assigning map args");
5232 +                               logerr(MODPREFIX "error assigning map args");
5233                                 goto error_out;
5234                         }
5235                         ctxt->m[i].argv = copy_argv(ctxt->m[i].argc, (const char **) args);
5236 @@ -201,7 +200,7 @@ int lookup_init(const char *my_mapfmt, int argc, const char *const *argv, void *
5237                 ctxt->m[i].mod = nss_open_lookup(my_mapfmt,
5238                                  ctxt->m[i].argc, ctxt->m[i].argv);
5239                 if (!ctxt->m[i].mod) {
5240 -                       error(LOGOPT_ANY, MODPREFIX "error opening module");
5241 +                       logerr(MODPREFIX "error opening module");
5242                         goto error_out;
5243                 }
5244         }
5245 @@ -211,7 +210,7 @@ int lookup_init(const char *my_mapfmt, int argc, const char *const *argv, void *
5246
5247  nomem:
5248         estr = strerror_r(errno, buf, MAX_ERR_BUF);
5249 -       crit(LOGOPT_ANY, MODPREFIX "error: %s", estr);
5250 +       logerr(MODPREFIX "error: %s", estr);
5251  error_out:
5252         if (ctxt) {
5253                 for (i = 0; i < ctxt->n; i++) {
5254 diff --git a/modules/lookup_nisplus.c b/modules/lookup_nisplus.c
5255 index 83e99e0..ff8bd49 100644
5256 --- a/modules/lookup_nisplus.c
5257 +++ b/modules/lookup_nisplus.c
5258 @@ -41,13 +41,13 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5259         ctxt = malloc(sizeof(struct lookup_context));
5260         if (!ctxt) {
5261                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5262 -               crit(LOGOPT_ANY, MODPREFIX "%s", estr);
5263 +               logerr(MODPREFIX "%s", estr);
5264                 return 1;
5265         }
5266
5267         if (argc < 1) {
5268                 free(ctxt);
5269 -               crit(LOGOPT_ANY, MODPREFIX "No map name");
5270 +               logmsg(MODPREFIX "No map name");
5271                 return 1;
5272         }
5273         ctxt->mapname = argv[0];
5274 @@ -59,7 +59,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5275         ctxt->domainname = nis_local_directory();
5276         if (!ctxt->domainname) {
5277                 free(ctxt);
5278 -               crit(LOGOPT_ANY, MODPREFIX "NIS+ domain not set");
5279 +               logmsg(MODPREFIX "NIS+ domain not set");
5280                 return 1;
5281         }
5282
5283 @@ -69,7 +69,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5284         ctxt->parse = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
5285         if (!ctxt->parse) {
5286                 free(ctxt);
5287 -               crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
5288 +               logerr(MODPREFIX "failed to open parse context");
5289                 return 1;
5290         }
5291         *context = ctxt;
5292 @@ -81,7 +81,8 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5293  {
5294         struct lookup_context *ctxt = (struct lookup_context *) context;
5295         unsigned int timeout = master->default_timeout;
5296 -       unsigned int logging =  master->default_logging;
5297 +       unsigned int logging = master->default_logging;
5298 +       unsigned int logopt =  master->logopt;
5299         char *tablename;
5300         nis_result *result;
5301         nis_object *this;
5302 @@ -95,7 +96,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5303         tablename = alloca(strlen(ctxt->mapname) + strlen(ctxt->domainname) + 20);
5304         if (!tablename) {
5305                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5306 -               crit(LOGOPT_ANY, MODPREFIX "alloca: %s", estr);
5307 +               logerr(MODPREFIX "alloca: %s", estr);
5308                 pthread_setcancelstate(cur_state, NULL);
5309                 return NSS_STATUS_UNAVAIL;
5310         }
5311 @@ -105,8 +106,8 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5312         result = nis_lookup(tablename, FOLLOW_PATH | FOLLOW_LINKS);
5313         if (result->status != NIS_SUCCESS && result->status != NIS_S_SUCCESS) {
5314                 nis_freeresult(result);
5315 -               crit(LOGOPT_ANY,
5316 -                    MODPREFIX "couldn't locat nis+ table %s", ctxt->mapname);
5317 +               crit(logopt,
5318 +                    MODPREFIX "couldn't locate nis+ table %s", ctxt->mapname);
5319                 pthread_setcancelstate(cur_state, NULL);
5320                 return NSS_STATUS_NOTFOUND;
5321         }
5322 @@ -116,7 +117,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5323         result = nis_list(tablename, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
5324         if (result->status != NIS_SUCCESS && result->status != NIS_S_SUCCESS) {
5325                 nis_freeresult(result);
5326 -               crit(LOGOPT_ANY,
5327 +               crit(logopt,
5328                      MODPREFIX "couldn't enumrate nis+ map %s", ctxt->mapname);
5329                 pthread_setcancelstate(cur_state, NULL);
5330                 return NSS_STATUS_UNAVAIL;
5331 @@ -139,8 +140,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5332
5333                 buffer = malloc(ENTRY_LEN(this, 0) + 1 + ENTRY_LEN(this, 1) + 1);
5334                 if (!buffer) {
5335 -                       error(LOGOPT_ANY,
5336 -                             MODPREFIX "could not malloc parse buffer");
5337 +                       logerr(MODPREFIX "could not malloc parse buffer");
5338                         continue;
5339                 }
5340
5341 @@ -182,7 +182,7 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
5342         tablename = alloca(strlen(ctxt->mapname) + strlen(ctxt->domainname) + 20);
5343         if (!tablename) {
5344                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5345 -               crit(LOGOPT_ANY, MODPREFIX "alloca: %s", estr);
5346 +               logerr(MODPREFIX "alloca: %s", estr);
5347                 pthread_setcancelstate(cur_state, NULL);
5348                 return NSS_STATUS_UNAVAIL;
5349         }
5350 @@ -193,7 +193,7 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
5351         if (result->status != NIS_SUCCESS && result->status != NIS_S_SUCCESS) {
5352                 nis_freeresult(result);
5353                 crit(ap->logopt,
5354 -                    MODPREFIX "couldn't locat nis+ table %s", ctxt->mapname);
5355 +                    MODPREFIX "couldn't locate nis+ table %s", ctxt->mapname);
5356                 pthread_setcancelstate(cur_state, NULL);
5357                 return NSS_STATUS_NOTFOUND;
5358         }
5359 @@ -274,7 +274,7 @@ static int lookup_one(struct autofs_point *ap,
5360                         strlen(ctxt->mapname) + strlen(ctxt->domainname) + 20);
5361         if (!tablename) {
5362                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5363 -               crit(LOGOPT_ANY, MODPREFIX "alloca: %s", estr);
5364 +               logerr(MODPREFIX "alloca: %s", estr);
5365                 pthread_setcancelstate(cur_state, NULL);
5366                 return -1;
5367         }
5368 @@ -327,7 +327,7 @@ static int lookup_wild(struct autofs_point *ap, struct lookup_context *ctxt)
5369         tablename = alloca(strlen(ctxt->mapname) + strlen(ctxt->domainname) + 20);
5370         if (!tablename) {
5371                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5372 -               crit(LOGOPT_ANY, MODPREFIX "alloca: %s", estr);
5373 +               logerr(MODPREFIX "alloca: %s", estr);
5374                 pthread_setcancelstate(cur_state, NULL);
5375                 return -1;
5376         }
5377 diff --git a/modules/lookup_program.c b/modules/lookup_program.c
5378 index 2fd521a..e28168e 100644
5379 --- a/modules/lookup_program.c
5380 +++ b/modules/lookup_program.c
5381 @@ -51,28 +51,26 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5382         ctxt = malloc(sizeof(struct lookup_context));
5383         if (!ctxt) {
5384                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5385 -               crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
5386 +               logerr(MODPREFIX "malloc: %s", estr);
5387                 return 1;
5388         }
5389
5390         if (argc < 1) {
5391 -               crit(LOGOPT_ANY, MODPREFIX "No map name");
5392 +               logmsg(MODPREFIX "No map name");
5393                 free(ctxt);
5394                 return 1;
5395         }
5396         ctxt->mapname = argv[0];
5397
5398         if (ctxt->mapname[0] != '/') {
5399 -               crit(LOGOPT_ANY,
5400 -                    MODPREFIX "program map %s is not an absolute pathname",
5401 +               logmsg(MODPREFIX "program map %s is not an absolute pathname",
5402                      ctxt->mapname);
5403                 free(ctxt);
5404                 return 1;
5405         }
5406
5407         if (access(ctxt->mapname, X_OK)) {
5408 -               crit(LOGOPT_ANY,
5409 -                    MODPREFIX "program map %s missing or not executable",
5410 +               logmsg(MODPREFIX "program map %s missing or not executable",
5411                      ctxt->mapname);
5412                 free(ctxt);
5413                 return 1;
5414 @@ -83,7 +81,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5415
5416         ctxt->parse = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
5417         if (!ctxt->parse) {
5418 -               crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
5419 +               logmsg(MODPREFIX "failed to open parse context");
5420                 free(ctxt);
5421                 return 1;
5422         }
5423 @@ -163,7 +161,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5424         mapent = (char *) malloc(MAPENT_MAX_LEN + 1);
5425         if (!mapent) {
5426                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5427 -               error(ap->logopt, MODPREFIX "malloc: %s", estr);
5428 +               logerr(MODPREFIX "malloc: %s", estr);
5429                 return NSS_STATUS_UNAVAIL;
5430         }
5431
5432 @@ -176,7 +174,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5433          */
5434         if (pipe(pipefd)) {
5435                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5436 -               error(ap->logopt, MODPREFIX "pipe: %s", estr);
5437 +               logerr(MODPREFIX "pipe: %s", estr);
5438                 goto out_free;
5439         }
5440         if (pipe(epipefd)) {
5441 @@ -188,7 +186,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5442         f = fork();
5443         if (f < 0) {
5444                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5445 -               error(ap->logopt, MODPREFIX "fork: %s", estr);
5446 +               logerr(MODPREFIX "fork: %s", estr);
5447                 close(pipefd[0]);
5448                 close(pipefd[1]);
5449                 close(epipefd[0]);
5450 @@ -271,8 +269,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5451                                                        ++alloci));
5452                                         if (!tmp) {
5453                                                 alloci--;
5454 -                                               error(ap->logopt,
5455 -                                                     MODPREFIX "realloc: %s",
5456 +                                               logerr(MODPREFIX "realloc: %s",
5457                                                       strerror(errno));
5458                                                 break;
5459                                         }
5460 @@ -308,12 +305,12 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5461                         } else if (ch == '\n') {
5462                                 *errp = '\0';
5463                                 if (errbuf[0])
5464 -                                       error(ap->logopt, ">> %s", errbuf);
5465 +                                       logmsg(">> %s", errbuf);
5466                                 errp = errbuf;
5467                         } else {
5468                                 if (errp >= &errbuf[1023]) {
5469                                         *errp = '\0';
5470 -                                       error(ap->logopt, ">> %s", errbuf);
5471 +                                       logmsg(">> %s", errbuf);
5472                                         errp = errbuf;
5473                                 }
5474                                 *(errp++) = ch;
5475 @@ -325,7 +322,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5476                 *mapp = '\0';
5477         if (errp > errbuf) {
5478                 *errp = '\0';
5479 -               error(ap->logopt, ">> %s", errbuf);
5480 +               logmsg(">> %s", errbuf);
5481         }
5482
5483         close(pipefd[0]);
5484 @@ -333,12 +330,12 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5485
5486         if (waitpid(f, &status, 0) != f) {
5487                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5488 -               error(ap->logopt, MODPREFIX "waitpid: %s", estr);
5489 +               logerr(MODPREFIX "waitpid: %s", estr);
5490                 goto out_free;
5491         }
5492
5493         if (mapp == mapent || !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
5494 -               msg(MODPREFIX "lookup for %s failed", name);
5495 +               info(ap->logopt, MODPREFIX "lookup for %s failed", name);
5496                 goto out_free;
5497         }
5498
5499 diff --git a/modules/lookup_userhome.c b/modules/lookup_userhome.c
5500 index efcab0b..680ddaf 100644
5501 --- a/modules/lookup_userhome.c
5502 +++ b/modules/lookup_userhome.c
5503 @@ -73,7 +73,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5504         /* Create the appropriate symlink */
5505         if (chdir(ap->path)) {
5506                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5507 -               error(ap->logopt, MODPREFIX "chdir failed: %s", estr);
5508 +               logerr(MODPREFIX "chdir failed: %s", estr);
5509                 return NSS_STATUS_UNAVAIL;
5510         }
5511
5512 @@ -88,7 +88,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5513
5514         if (symlink(pw->pw_dir, name) && errno != EEXIST) {
5515                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5516 -               error(ap->logopt, MODPREFIX "symlink failed: %s", estr);
5517 +               logerr(MODPREFIX "symlink failed: %s", estr);
5518                 return NSS_STATUS_UNAVAIL;
5519         }
5520
5521 diff --git a/modules/lookup_yp.c b/modules/lookup_yp.c
5522 index da280cc..63fc8e3 100644
5523 --- a/modules/lookup_yp.c
5524 +++ b/modules/lookup_yp.c
5525 @@ -45,12 +45,14 @@ struct lookup_context {
5526  struct callback_master_data {
5527         unsigned timeout;
5528         unsigned logging;
5529 +       unsigned logopt;
5530         time_t age;
5531  };
5532
5533  struct callback_data {
5534         struct autofs_point *ap;
5535         struct map_source *source;
5536 +       unsigned logopt;
5537         time_t age;
5538  };
5539
5540 @@ -111,20 +113,18 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5541         ctxt = malloc(sizeof(struct lookup_context));
5542         if (!ctxt) {
5543                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5544 -               crit(LOGOPT_ANY, MODPREFIX "%s", estr);
5545 +               logerr(MODPREFIX "%s", estr);
5546                 return 1;
5547         }
5548         memset(ctxt, 0, sizeof(struct lookup_context));
5549
5550         if (argc < 1) {
5551                 free(ctxt);
5552 -               crit(LOGOPT_ANY, MODPREFIX "no map name");
5553 +               logerr(MODPREFIX "no map name");
5554                 return 1;
5555         }
5556         ctxt->mapname = argv[0];
5557
5558 -       debug(LOGOPT_NONE, MODPREFIX "ctxt->mapname=%s", ctxt->mapname);
5559 -
5560         /* This should, but doesn't, take a const char ** */
5561         err = yp_get_default_domain((char **) &ctxt->domainname);
5562         if (err) {
5563 @@ -133,8 +133,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5564                 memcpy(name, ctxt->mapname, len);
5565                 name[len] = '\0';
5566                 free(ctxt);
5567 -               debug(LOGOPT_NONE, MODPREFIX "map %s: %s", name,
5568 -                      yperr_string(err));
5569 +               logerr(MODPREFIX "map %s: %s", name, yperr_string(err));
5570                 return 1;
5571         }
5572
5573 @@ -146,7 +145,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5574         ctxt->parse = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
5575         if (!ctxt->parse) {
5576                 free(ctxt);
5577 -               crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
5578 +               logmsg(MODPREFIX "failed to open parse context");
5579                 return 1;
5580         }
5581         *context = ctxt;
5582 @@ -161,6 +160,7 @@ int yp_all_master_callback(int status, char *ypkey, int ypkeylen,
5583                         (struct callback_master_data *) ypcb_data;
5584         unsigned int timeout = cbdata->timeout;
5585         unsigned int logging = cbdata->logging;
5586 +       unsigned int logopt = cbdata->logopt;
5587         time_t age = cbdata->age;
5588         char *buffer;
5589         unsigned int len;
5590 @@ -182,7 +182,7 @@ int yp_all_master_callback(int status, char *ypkey, int ypkeylen,
5591
5592         buffer = alloca(len);
5593         if (!buffer) {
5594 -               error(LOGOPT_ANY, MODPREFIX "could not malloc parse buffer");
5595 +               error(logopt, MODPREFIX "could not malloc parse buffer");
5596                 return 0;
5597         }
5598         memset(buffer, 0, len);
5599 @@ -201,6 +201,8 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5600         struct lookup_context *ctxt = (struct lookup_context *) context;
5601         struct ypall_callback ypcb;
5602         struct callback_master_data ypcb_data;
5603 +       unsigned int logging = master->default_logging;
5604 +       unsigned int logopt = master->logopt;
5605         char *mapname;
5606         int err;
5607
5608 @@ -211,7 +213,8 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5609         strcpy(mapname, ctxt->mapname);
5610
5611         ypcb_data.timeout = master->default_timeout;
5612 -       ypcb_data.logging = master->default_logging;
5613 +       ypcb_data.logging = logging;
5614 +       ypcb_data.logopt = logopt;
5615         ypcb_data.age = age;
5616
5617         ypcb.foreach = yp_all_master_callback;
5618 @@ -232,7 +235,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5619                 if (err == YPERR_SUCCESS)
5620                         return NSS_STATUS_SUCCESS;
5621
5622 -               warn(LOGOPT_ANY,
5623 +               info(logopt,
5624                      MODPREFIX "read of master map %s failed: %s",
5625                      mapname, yperr_string(err));
5626
5627 @@ -249,6 +252,7 @@ int yp_all_callback(int status, char *ypkey, int ypkeylen,
5628         struct autofs_point *ap = cbdata->ap;
5629         struct map_source *source = cbdata->source;
5630         struct mapent_cache *mc = source->mc;
5631 +       unsigned int logopt = cbdata->logopt;
5632         time_t age = cbdata->age;
5633         char *key, *mapent;
5634         int ret;
5635 @@ -264,8 +268,10 @@ int yp_all_callback(int status, char *ypkey, int ypkeylen,
5636                 return 0;
5637
5638         key = sanitize_path(ypkey, ypkeylen, ap->type, ap->logopt);
5639 -       if (!key)
5640 +       if (!key) {
5641 +               error(logopt, MODPREFIX "invalid path %s", ypkey);
5642                 return 0;
5643 +       }
5644
5645         mapent = alloca(vallen + 1);
5646         strncpy(mapent, val, vallen);
5647 @@ -288,6 +294,7 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
5648         struct lookup_context *ctxt = (struct lookup_context *) context;
5649         struct ypall_callback ypcb;
5650         struct callback_data ypcb_data;
5651 +       unsigned int logopt = ap->logopt;
5652         struct map_source *source;
5653         char *mapname;
5654         int err;
5655 @@ -298,6 +305,7 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
5656
5657         ypcb_data.ap = ap;
5658         ypcb_data.source = source;
5659 +       ypcb_data.logopt = logopt;
5660         ypcb_data.age = age;
5661
5662         ypcb.foreach = yp_all_callback;
5663 diff --git a/modules/mount_autofs.c b/modules/mount_autofs.c
5664 index c45b91b..356fb14 100644
5665 --- a/modules/mount_autofs.c
5666 +++ b/modules/mount_autofs.c
5667 @@ -64,7 +64,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name,
5668         fullpath = alloca(strlen(root) + name_len + 2);
5669         if (!fullpath) {
5670                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5671 -               error(ap->logopt, MODPREFIX "alloca: %s", estr);
5672 +               logerr(MODPREFIX "alloca: %s", estr);
5673                 return 1;
5674         }
5675
5676 @@ -156,7 +156,6 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name,
5677         }
5678         nap = entry->ap;
5679         nap->parent = ap;
5680 -       set_mnt_logging(nap);
5681
5682         argc = 1;
5683
5684 @@ -208,7 +207,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name,
5685                 return 1;
5686         }
5687
5688 -       source->mc = cache_init(source);
5689 +       source->mc = cache_init(entry->ap, source);
5690         if (!source->mc) {
5691                 error(ap->logopt, MODPREFIX "failed to init source cache");
5692                 master_free_mapent(entry);
5693 diff --git a/modules/mount_bind.c b/modules/mount_bind.c
5694 index cb17ce4..04284f5 100644
5695 --- a/modules/mount_bind.c
5696 +++ b/modules/mount_bind.c
5697 @@ -52,16 +52,14 @@ int mount_init(void **context)
5698         if (lstat(t1_dir, &st1) == -1)
5699                 goto out;
5700
5701 -       err = spawn_mount(log_debug, "-n", "--bind", t1_dir, t2_dir, NULL);
5702 +       err = spawn_mount(LOGOPT_NONE, "-n", "--bind", t1_dir, t2_dir, NULL);
5703         if (err == 0 &&
5704             lstat(t2_dir, &st2) == 0 &&
5705             st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino) {
5706                 bind_works = 1;
5707         }
5708
5709 -       debug(LOGOPT_NONE, MODPREFIX "bind_works = %d", bind_works);
5710 -
5711 -       spawn_umount(log_debug, "-n", t2_dir, NULL);
5712 +       spawn_umount(LOGOPT_NONE, "-n", t2_dir, NULL);
5713
5714  out:
5715         rmdir(t1_dir);
5716 @@ -91,7 +89,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5717         fullpath = alloca(rlen + name_len + 2);
5718         if (!fullpath) {
5719                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5720 -               error(ap->logopt, MODPREFIX "alloca: %s", estr);
5721 +               logerr(MODPREFIX "alloca: %s", estr);
5722                 return 1;
5723         }
5724
5725 @@ -139,7 +137,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5726                       "calling mount --bind " SLOPPY " -o %s %s %s",
5727                       options, what, fullpath);
5728
5729 -               err = spawn_bind_mount(log_debug,
5730 +               err = spawn_bind_mount(ap->logopt,
5731                              SLOPPYOPT "-o", options, what, fullpath, NULL);
5732
5733                 if (err) {
5734 diff --git a/modules/mount_changer.c b/modules/mount_changer.c
5735 index 6e04c7c..08d9147 100644
5736 --- a/modules/mount_changer.c
5737 +++ b/modules/mount_changer.c
5738 @@ -66,7 +66,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5739         fullpath = alloca(rlen + name_len + 2);
5740         if (!fullpath) {
5741                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5742 -               error(ap->logopt, MODPREFIX "alloca: %s", estr);
5743 +               logerr(MODPREFIX "alloca: %s", estr);
5744                 return 1;
5745         }
5746
5747 @@ -80,7 +80,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5748
5749         debug(ap->logopt, MODPREFIX "calling umount %s", what);
5750
5751 -       err = spawn_umount(log_debug, what, NULL);
5752 +       err = spawn_umount(ap->logopt, what, NULL);
5753         if (err) {
5754                 error(ap->logopt,
5755                       MODPREFIX
5756 @@ -115,18 +115,18 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5757                       MODPREFIX "calling mount -t %s " SLOPPY "-o %s %s %s",
5758                       fstype, options, what, fullpath);
5759
5760 -               err = spawn_mount(log_debug, "-t", fstype,
5761 +               err = spawn_mount(ap->logopt, "-t", fstype,
5762                              SLOPPYOPT "-o", options, what, fullpath, NULL);
5763         } else {
5764                 debug(ap->logopt,
5765                       MODPREFIX "calling mount -t %s %s %s",
5766                       fstype, what, fullpath);
5767
5768 -               err = spawn_mount(log_debug, "-t", fstype, what, fullpath, NULL);
5769 +               err = spawn_mount(ap->logopt, "-t", fstype, what, fullpath, NULL);
5770         }
5771
5772         if (err) {
5773 -               msg(MODPREFIX "failed to mount %s (type %s) on %s",
5774 +               info(ap->logopt, MODPREFIX "failed to mount %s (type %s) on %s",
5775                     what, fstype, fullpath);
5776
5777                 if (ap->type != LKP_INDIRECT)
5778 @@ -137,7 +137,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5779
5780                 return 1;
5781         } else {
5782 -               msg(MODPREFIX "mounted %s type %s on %s",
5783 +               info(ap->logopt, MODPREFIX "mounted %s type %s on %s",
5784                     what, fstype, fullpath);
5785                 return 0;
5786         }
5787 @@ -161,7 +161,7 @@ int swapCD(const char *device, const char *slotName)
5788         /* open device */
5789         fd = open(device, O_RDONLY | O_NONBLOCK);
5790         if (fd < 0) {
5791 -               error(LOGOPT_ANY, MODPREFIX "Opening device %s failed : %s",
5792 +               logerr(MODPREFIX "Opening device %s failed : %s",
5793                       device, strerror(errno));
5794                 return 1;
5795         }
5796 @@ -174,7 +174,7 @@ int swapCD(const char *device, const char *slotName)
5797         /* Check CD player status */
5798         total_slots_available = ioctl(fd, CDROM_CHANGER_NSLOTS);
5799         if (total_slots_available <= 1) {
5800 -               error(LOGOPT_ANY, MODPREFIX
5801 +               logerr(MODPREFIX
5802                       "Device %s is not an ATAPI compliant CD changer.",
5803                       device);
5804                 return 1;
5805 @@ -183,14 +183,14 @@ int swapCD(const char *device, const char *slotName)
5806         /* load */
5807         slot = ioctl(fd, CDROM_SELECT_DISC, slot);
5808         if (slot < 0) {
5809 -               error(LOGOPT_ANY, MODPREFIX "CDROM_SELECT_DISC failed");
5810 +               logerr(MODPREFIX "CDROM_SELECT_DISC failed");
5811                 return 1;
5812         }
5813
5814         /* close device */
5815         status = close(fd);
5816         if (status != 0) {
5817 -               error(LOGOPT_ANY, MODPREFIX "close failed for `%s': %s",
5818 +               logerr(MODPREFIX "close failed for `%s': %s",
5819                       device, strerror(errno));
5820                 return 1;
5821         }
5822 diff --git a/modules/mount_ext2.c b/modules/mount_ext2.c
5823 index 45f0615..8cf9937 100644
5824 --- a/modules/mount_ext2.c
5825 +++ b/modules/mount_ext2.c
5826 @@ -58,7 +58,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5827         fullpath = alloca(rlen + name_len + 2);
5828         if (!fullpath) {
5829                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5830 -               error(ap->logopt, MODPREFIX "alloca: %s", estr);
5831 +               logerr(MODPREFIX "alloca: %s", estr);
5832                 return 1;
5833         }
5834
5835 @@ -108,11 +108,11 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5836         if (ro) {
5837                 debug(ap->logopt,
5838                       MODPREFIX "calling %s -n %s", fsck_prog, what);
5839 -               err = spawnl(log_debug, fsck_prog, fsck_prog, "-n", what, NULL);
5840 +               err = spawnl(ap->logopt, fsck_prog, fsck_prog, "-n", what, NULL);
5841         } else {
5842                 debug(ap->logopt,
5843                       MODPREFIX "calling %s -p %s", fsck_prog, what);
5844 -               err = spawnl(log_debug, fsck_prog, fsck_prog, "-p", what, NULL);
5845 +               err = spawnl(ap->logopt, fsck_prog, fsck_prog, "-p", what, NULL);
5846         }
5847
5848         /*
5849 @@ -132,17 +132,17 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5850                 debug(ap->logopt,
5851                       MODPREFIX "calling mount -t %s " SLOPPY "-o %s %s %s",
5852                       fstype, options, what, fullpath);
5853 -               err = spawn_mount(log_debug, "-t", fstype,
5854 +               err = spawn_mount(ap->logopt, "-t", fstype,
5855                              SLOPPYOPT "-o", options, what, fullpath, NULL);
5856         } else {
5857                 debug(ap->logopt,
5858                       MODPREFIX "calling mount -t %s %s %s",
5859                       fstype, what, fullpath);
5860 -               err = spawn_mount(log_debug, "-t", fstype, what, fullpath, NULL);
5861 +               err = spawn_mount(ap->logopt, "-t", fstype, what, fullpath, NULL);
5862         }
5863
5864         if (err) {
5865 -               msg(MODPREFIX "failed to mount %s (type %s) on %s",
5866 +               info(ap->logopt, MODPREFIX "failed to mount %s (type %s) on %s",
5867                     what, fstype, fullpath);
5868
5869                 if (ap->type != LKP_INDIRECT)
5870 @@ -153,7 +153,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5871
5872                 return 1;
5873         } else {
5874 -               debug(ap->logopt,
5875 +               info(ap->logopt,
5876                       MODPREFIX "mounted %s type %s on %s",
5877                       what, fstype, fullpath);
5878                 return 0;
5879 diff --git a/modules/mount_generic.c b/modules/mount_generic.c
5880 index 1f43baa..85b4391 100644
5881 --- a/modules/mount_generic.c
5882 +++ b/modules/mount_generic.c
5883 @@ -57,7 +57,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5884         fullpath = alloca(rlen + name_len + 2);
5885         if (!fullpath) {
5886                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5887 -               error(ap->logopt, MODPREFIX "alloca: %s", estr);
5888 +               logerr(MODPREFIX "alloca: %s", estr);
5889                 return 1;
5890         }
5891
5892 @@ -93,16 +93,16 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5893                       MODPREFIX "calling mount -t %s " SLOPPY "-o %s %s %s",
5894                       fstype, options, what, fullpath);
5895
5896 -               err = spawn_mount(log_debug, "-t", fstype,
5897 +               err = spawn_mount(ap->logopt, "-t", fstype,
5898                              SLOPPYOPT "-o", options, what, fullpath, NULL);
5899         } else {
5900                 debug(ap->logopt, MODPREFIX "calling mount -t %s %s %s",
5901                       fstype, what, fullpath);
5902 -               err = spawn_mount(log_debug, "-t", fstype, what, fullpath, NULL);
5903 +               err = spawn_mount(ap->logopt, "-t", fstype, what, fullpath, NULL);
5904         }
5905
5906         if (err) {
5907 -               msg(MODPREFIX "failed to mount %s (type %s) on %s",
5908 +               info(ap->logopt, MODPREFIX "failed to mount %s (type %s) on %s",
5909                      what, fstype, fullpath);
5910
5911                 if (ap->type != LKP_INDIRECT)
5912 @@ -113,7 +113,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5913
5914                 return 1;
5915         } else {
5916 -               msg(MODPREFIX "mounted %s type %s on %s",
5917 +               info(ap->logopt, MODPREFIX "mounted %s type %s on %s",
5918                     what, fstype, fullpath);
5919                 return 0;
5920         }
5921 diff --git a/modules/mount_nfs.c b/modules/mount_nfs.c
5922 index e4480c5..bad21fc 100644
5923 --- a/modules/mount_nfs.c
5924 +++ b/modules/mount_nfs.c
5925 @@ -133,14 +133,14 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5926         else
5927                 vers = NFS_VERS_MASK | NFS_PROTO_MASK;
5928
5929 -       if (!parse_location(&hosts, what)) {
5930 -               warn(ap->logopt, MODPREFIX "no hosts available");
5931 +       if (!parse_location(ap->logopt, &hosts, what)) {
5932 +               info(ap->logopt, MODPREFIX "no hosts available");
5933                 return 1;
5934         }
5935 -       prune_host_list(&hosts, vers, nfsoptions, ap->random_selection);
5936 +       prune_host_list(ap->logopt, &hosts, vers, nfsoptions, ap->random_selection);
5937
5938         if (!hosts) {
5939 -               warn(ap->logopt, MODPREFIX "no hosts available");
5940 +               info(ap->logopt, MODPREFIX "no hosts available");
5941                 return 1;
5942         }
5943
5944 @@ -159,7 +159,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5945         fullpath = alloca(rlen + name_len + 2);
5946         if (!fullpath) {
5947                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5948 -               error(ap->logopt, MODPREFIX "alloca: %s", estr);
5949 +               logerr(MODPREFIX "alloca: %s", estr);
5950                 free_host_list(&hosts);
5951                 return 1;
5952         }
5953 @@ -252,19 +252,19 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5954                               MODPREFIX "calling mount -t %s " SLOPPY
5955                               "-o %s %s %s", fstype, nfsoptions, loc, fullpath);
5956
5957 -                       err = spawn_mount(log_debug,
5958 +                       err = spawn_mount(ap->logopt,
5959                                           "-t", fstype, SLOPPYOPT "-o",
5960                                           nfsoptions, loc, fullpath, NULL);
5961                 } else {
5962                         debug(ap->logopt,
5963                               MODPREFIX "calling mount -t %s %s %s",
5964                               fstype, loc, fullpath);
5965 -                       err = spawn_mount(log_debug,
5966 +                       err = spawn_mount(ap->logopt,
5967                                           "-t", fstype, loc, fullpath, NULL);
5968                 }
5969
5970                 if (!err) {
5971 -                       msg(MODPREFIX "mounted %s on %s", loc, fullpath);
5972 +                       info(ap->logopt, MODPREFIX "mounted %s on %s", loc, fullpath);
5973                         free(loc);
5974                         free_host_list(&hosts);
5975                         ap->ghost = save_ghost;
5976 @@ -280,7 +280,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5977
5978         /* If we get here we've failed to complete the mount */
5979
5980 -       msg(MODPREFIX "nfs: mount failure %s on %s", what, fullpath);
5981 +       info(ap->logopt, MODPREFIX "nfs: mount failure %s on %s", what, fullpath);
5982
5983         if (ap->type != LKP_INDIRECT)
5984                 return 1;
5985 diff --git a/modules/parse_sun.c b/modules/parse_sun.c
5986 index 079bda6..186e567 100644
5987 --- a/modules/parse_sun.c
5988 +++ b/modules/parse_sun.c
5989 @@ -277,7 +277,7 @@ int parse_init(int argc, const char *const *argv, void **context)
5990
5991         if (!(ctxt = (struct parse_context *) malloc(sizeof(struct parse_context)))) {
5992                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5993 -               crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
5994 +               logerr(MODPREFIX "malloc: %s", estr);
5995                 *context = NULL;
5996                 return 1;
5997         }
5998 @@ -302,7 +302,7 @@ int parse_init(int argc, const char *const *argv, void **context)
5999
6000                                 if (!def) {
6001                                         char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6002 -                                       error(LOGOPT_ANY, MODPREFIX "strdup: %s", estr);
6003 +                                       logerr(MODPREFIX "strdup: %s", estr);
6004                                         break;
6005                                 }
6006
6007 @@ -387,7 +387,7 @@ int parse_init(int argc, const char *const *argv, void **context)
6008                         if (!noptstr) {
6009                                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6010                                 kill_context(ctxt);
6011 -                               crit(LOGOPT_ANY, MODPREFIX "%s", estr);
6012 +                               logerr(MODPREFIX "%s", estr);
6013                                 *context = NULL;
6014                                 return 1;
6015                         }
6016 @@ -408,7 +408,7 @@ int parse_init(int argc, const char *const *argv, void **context)
6017                         char *tmp = concat_options(gbl_options, ctxt->optstr);
6018                         if (!tmp) {
6019                                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6020 -                               error(LOGOPT_ANY, MODPREFIX "concat_options: %s", estr);
6021 +                               logerr(MODPREFIX "concat_options: %s", estr);
6022                                 free(gbl_options);
6023                         } else
6024                                 ctxt->optstr = tmp;
6025 @@ -472,7 +472,7 @@ static char *concat_options(char *left, char *right)
6026
6027         if (ret == NULL) {
6028                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6029 -               error(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
6030 +               logerr(MODPREFIX "malloc: %s", estr);
6031                 return NULL;
6032         }
6033
6034 @@ -637,8 +637,7 @@ static int check_is_multi(const char *mapent)
6035         int not_first_chunk = 0;
6036
6037         if (!p) {
6038 -               crit(LOGOPT_ANY,
6039 -                    MODPREFIX "unexpected NULL map entry pointer");
6040 +               logerr(MODPREFIX "unexpected NULL map entry pointer");
6041                 return 0;
6042         }
6043
6044 @@ -1021,7 +1020,7 @@ int parse_mount(struct autofs_point *ap, const char *name,
6045         pmapent = alloca(mapent_len + 1);
6046         if (!pmapent) {
6047                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6048 -               error(ap->logopt, MODPREFIX "alloca: %s", estr);
6049 +               logerr(MODPREFIX "alloca: %s", estr);
6050                 ctxt->subst = removestdenv(ctxt->subst);
6051                 macro_unlock();
6052                 pthread_setcancelstate(cur_state, NULL);
6053 @@ -1041,7 +1040,7 @@ int parse_mount(struct autofs_point *ap, const char *name,
6054         options = strdup(ctxt->optstr ? ctxt->optstr : "");
6055         if (!options) {
6056                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6057 -               error(ap->logopt, MODPREFIX "strdup: %s", estr);
6058 +               logerr(MODPREFIX "strdup: %s", estr);
6059                 return 1;
6060         }
6061         optlen = strlen(options);
6062 @@ -1119,7 +1118,7 @@ int parse_mount(struct autofs_point *ap, const char *name,
6063                         if (!m_root) {
6064                                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6065                                 free(options);
6066 -                               error(ap->logopt, MODPREFIX "alloca: %s", estr);
6067 +                               logerr(MODPREFIX "alloca: %s", estr);
6068                                 return 1;
6069                         }
6070                         strcpy(m_root, name);
6071 @@ -1129,7 +1128,7 @@ int parse_mount(struct autofs_point *ap, const char *name,
6072                         if (!m_root) {
6073                                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6074                                 free(options);
6075 -                               error(ap->logopt, MODPREFIX "alloca: %s", estr);
6076 +                               logerr(MODPREFIX "alloca: %s", estr);
6077                                 return 1;
6078                         }
6079                         strcpy(m_root, ap->path);
6080 diff --git a/modules/replicated.c b/modules/replicated.c
6081 index e15587c..14b20a9 100644
6082 --- a/modules/replicated.c
6083 +++ b/modules/replicated.c
6084 @@ -113,7 +113,7 @@ static unsigned int get_proximity(const char *host_addr, int addr_len)
6085         sock = socket(AF_INET, SOCK_DGRAM, 0);
6086         if (sock < 0) {
6087                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6088 -               error(LOGOPT_ANY, "socket creation failed: %s", estr);
6089 +               logerr("socket creation failed: %s", estr);
6090                 return PROXIMITY_ERROR;
6091         }
6092
6093 @@ -127,7 +127,7 @@ static unsigned int get_proximity(const char *host_addr, int addr_len)
6094         ret = ioctl(sock, SIOCGIFCONF, &ifc);
6095         if (ret == -1) {
6096                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6097 -               error(LOGOPT_ANY, "ioctl: %s", estr);
6098 +               logerr("ioctl: %s", estr);
6099                 close(sock);
6100                 return PROXIMITY_ERROR;
6101         }
6102 @@ -176,7 +176,7 @@ static unsigned int get_proximity(const char *host_addr, int addr_len)
6103                         ret = ioctl(sock, SIOCGIFNETMASK, &nmptr);
6104                         if (ret == -1) {
6105                                 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6106 -                               error(LOGOPT_ANY, "ioctl: %s", estr);
6107 +                               logerr("ioctl: %s", estr);
6108                                 close(sock);
6109                                 return PROXIMITY_ERROR;
6110                         }
6111 @@ -387,7 +387,7 @@ static unsigned short get_port_option(const char *options)
6112         return (unsigned short) port;
6113  }
6114
6115 -static unsigned int get_nfs_info(struct host *host,
6116 +static unsigned int get_nfs_info(unsigned logopt, struct host *host,
6117                          struct conn_info *pm_info, struct conn_info *rpc_info,
6118                          const char *proto, unsigned int version,
6119                          const char *options, unsigned int random_selection)
6120 @@ -533,7 +533,7 @@ done_ver:
6121         return supported;
6122  }
6123
6124 -static int get_vers_and_cost(struct host *host,
6125 +static int get_vers_and_cost(unsigned logopt, struct host *host,
6126                              unsigned int version, const char *options,
6127                              unsigned int random_selection)
6128  {
6129 @@ -559,7 +559,7 @@ static int get_vers_and_cost(struct host *host,
6130         vers &= version;
6131
6132         if (version & UDP_REQUESTED) {
6133 -               supported = get_nfs_info(host,
6134 +               supported = get_nfs_info(logopt, host,
6135                                         &pm_info, &rpc_info, "udp", vers,
6136                                         options, random_selection);
6137                 if (supported) {
6138 @@ -569,7 +569,7 @@ static int get_vers_and_cost(struct host *host,
6139         }
6140
6141         if (version & TCP_REQUESTED) {
6142 -               supported = get_nfs_info(host,
6143 +               supported = get_nfs_info(logopt, host,
6144                                          &pm_info, &rpc_info, "tcp", vers,
6145                                          options, random_selection);
6146                 if (supported) {
6147 @@ -581,7 +581,7 @@ static int get_vers_and_cost(struct host *host,
6148         return ret;
6149  }
6150
6151 -static int get_supported_ver_and_cost(struct host *host,
6152 +static int get_supported_ver_and_cost(unsigned logopt, struct host *host,
6153                                       unsigned int version, const char *options,
6154                                       unsigned int random_selection)
6155  {
6156 @@ -636,7 +636,7 @@ static int get_supported_ver_and_cost(struct host *host,
6157                 vers = NFS4_VERSION;
6158                 break;
6159         default:
6160 -               crit(LOGOPT_ANY, "called with invalid version: 0x%x\n", version);
6161 +               crit(logopt, "called with invalid version: 0x%x\n", version);
6162                 return 0;
6163         }
6164
6165 @@ -701,7 +701,7 @@ done:
6166         return 0;
6167  }
6168
6169 -int prune_host_list(struct host **list,
6170 +int prune_host_list(unsigned logopt, struct host **list,
6171                     unsigned int vers, const char *options,
6172                     unsigned int random_selection)
6173  {
6174 @@ -742,7 +742,7 @@ int prune_host_list(struct host **list,
6175                         break;
6176
6177                 if (this->name) {
6178 -                       status = get_vers_and_cost(this, vers,
6179 +                       status = get_vers_and_cost(logopt, this, vers,
6180                                                    options, random_selection);
6181                         if (!status) {
6182                                 if (this == first) {
6183 @@ -833,7 +833,7 @@ int prune_host_list(struct host **list,
6184                         remove_host(list, this);
6185                         add_host(&new, this);
6186                 } else {
6187 -                       status = get_supported_ver_and_cost(this,
6188 +                       status = get_supported_ver_and_cost(logopt, this,
6189                                                 selected_version, options,
6190                                                 random_selection);
6191                         if (status) {
6192 @@ -886,11 +886,9 @@ static int add_host_addrs(struct host **list, const char *host, unsigned int wei
6193                         buf, MAX_IFC_BUF, &result, &ghn_errno);
6194         if (ret || !result) {
6195                 if (ghn_errno == -1)
6196 -                       error(LOGOPT_ANY,
6197 -                             "host %s: lookup failure %d", host, errno);
6198 +                       logmsg("host %s: lookup failure %d", host, errno);
6199                 else
6200 -                       error(LOGOPT_ANY,
6201 -                             "host %s: lookup failure %d", host, ghn_errno);
6202 +                       logmsg("host %s: lookup failure %d", host, ghn_errno);
6203                 return 0;
6204         }
6205
6206 @@ -965,7 +963,7 @@ static int add_local_path(struct host **hosts, const char *path)
6207         return 1;
6208  }
6209
6210 -int parse_location(struct host **hosts, const char *list)
6211 +int parse_location(unsigned logopt, struct host **hosts, const char *list)
6212  {
6213         char *str, *p, *delim;
6214         unsigned int empty = 1;
6215 @@ -1072,8 +1070,7 @@ void dump_host_list(struct host *hosts)
6216
6217         this = hosts;
6218         while (this) {
6219 -               debug(LOGOPT_ANY,
6220 -                     "name %s path %s version %x proximity %u weight %u cost %u",
6221 +               logmsg("name %s path %s version %x proximity %u weight %u cost %u",
6222                       this->name, this->path, this->version,
6223                       this->proximity, this->weight, this->cost);
6224                 this = this->next;