external/bsd/am-utils/dist/conf/mtab/mtab_linux.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (c) 1997-2009 Erez Zadok
   5  * Copyright (c) 1990 Jan-Simon Pendry
   6  * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
   7  * Copyright (c) 1990 The Regents of the University of California.
   8  * All rights reserved.
   9  *
  10  * This code is derived from software contributed to Berkeley by
  11  * Jan-Simon Pendry at Imperial College, London.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. All advertising materials mentioning features or use of this software
  22  *    must display the following acknowledgment:
  23  *      This product includes software developed by the University of
  24  *      California, Berkeley and its contributors.
  25  * 4. Neither the name of the University nor the names of its contributors
  26  *    may be used to endorse or promote products derived from this software
  27  *    without specific prior written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  30  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  31  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  32  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  33  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  34  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  35  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  37  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  38  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  39  * SUCH DAMAGE.
  40  *
  41  *
  42  * File: am-utils/conf/mtab/mtab_linux.c
  43  *
  44  */
  45
  46 /* This file was adapted by Red Hat for Linux from mtab_file.c */
  47
  48 /*
  49  * The locking code must be kept in sync with that used
  50  * by the mount command in util-linux, otherwise you'll
  51  * end with with race conditions leading to a corrupt
  52  * /etc/mtab, particularly when AutoFS is used on same
  53  * machine as AMD.
  54  */
  55
  56 #ifdef HAVE_CONFIG_H
  57 # include <config.h>
  58 #endif /* HAVE_CONFIG_H */
  59 #include <am_defs.h>
  60 #include <amu.h>
  61
  62 #define NFILE_RETRIES   10      /* number of retries (seconds) */
  63 #define LOCK_TIMEOUT    10
  64
  65 #ifdef MOUNT_TABLE_ON_FILE
  66
  67 # define PROC_MOUNTS             "/proc/mounts"
  68
  69 static FILE *mnt_file = NULL;
  70 /* Information about mtab. ------------------------------------*/
  71 static int have_mtab_info = 0;
  72 static int var_mtab_does_not_exist = 0;
  73 static int var_mtab_is_a_symlink = 0;
  74 /* Flag for already existing lock file. */
  75 static int we_created_lockfile = 0;
  76 static int lockfile_fd = -1;
  77
  78
  79 static void
  80 get_mtab_info(void)
  81 {
  82   struct stat mtab_stat;
  83
  84   if (!have_mtab_info) {
  85     if (lstat(MOUNTED, &mtab_stat))
  86       var_mtab_does_not_exist = 1;
  87     else if (S_ISLNK(mtab_stat.st_mode))
  88       var_mtab_is_a_symlink = 1;
  89     have_mtab_info = 1;
  90   }
  91 }
  92
  93
  94 static int
  95 mtab_is_a_symlink(void)
  96 {
  97   get_mtab_info();
  98   return var_mtab_is_a_symlink;
  99 }
 100
 101
 102 static int
 103 mtab_is_writable()
 104 {
 105   static int ret = -1;
 106
 107   /*
 108    * Should we write to /etc/mtab upon an update?  Probably not if it is a
 109    * symlink to /proc/mounts, since that would create a file /proc/mounts in
 110    * case the proc filesystem is not mounted.
 111    */
 112   if (mtab_is_a_symlink())
 113     return 0;
 114
 115   if (ret == -1) {
 116     int fd = open(MOUNTED, O_RDWR | O_CREAT, 0644);
 117     if (fd >= 0) {
 118       close(fd);
 119       ret = 1;
 120     } else
 121       ret = 0;
 122   }
 123   return ret;
 124 }
 125
 126
 127 static void
 128 setlkw_timeout(int sig)
 129 {
 130   /* nothing, fcntl will fail anyway */
 131 }
 132
 133
 134 /*
 135  * Create the lock file.
 136  * The lock file will be removed if we catch a signal or when we exit.
 137  *
 138  * The old code here used flock on a lock file /etc/mtab~ and deleted
 139  * this lock file afterwards.  However, as rgooch remarks, that has a
 140  * race: a second mount may be waiting on the lock and proceed as
 141  * soon as the lock file is deleted by the first mount, and immediately
 142  * afterwards a third mount comes, creates a new /etc/mtab~, applies
 143  * flock to that, and also proceeds, so that the second and third mount
 144  * now both are scribbling in /etc/mtab.
 145  * The new code uses a link() instead of a creat(), where we proceed
 146  * only if it was us that created the lock, and hence we always have
 147  * to delete the lock afterwards.  Now the use of flock() is in principle
 148  * superfluous, but avoids an arbitrary sleep().
 149  */
 150
 151 /*
 152  * Where does the link point to?  Obvious choices are mtab and mtab~~.
 153  * HJLu points out that the latter leads to races.  Right now we use
 154  * mtab~.<pid> instead.
 155  */
 156 #define MOUNTED_LOCK "/etc/mtab~"
 157 #define MOUNTLOCK_LINKTARGET           MOUNTED_LOCK "%d"
 158
 159 int
 160 lock_mtab(void)
 161 {
 162   int tries = 100000, i;
 163   char *linktargetfile;
 164   size_t l;
 165
 166   /*
 167    * Redhat's original code set a signal handler called "handler()" for all
 168    * non-ALRM signals.  The handler called unlock_mntlist(), plog'ed the
 169    * signal name, and then exit(1)!  Never, ever, exit() from inside a
 170    * utility function.  This messed up Amd's careful signal-handling code,
 171    * and caused Amd to abort uncleanly only any other "innocent" signal
 172    * (even simple SIGUSR1), leaving behind a hung Amd mnt point.  That code
 173    * should have at least restored the signal handlers' states upon a
 174    * successful mtab unlocking.  Anyway, that handler was unnecessary,
 175    * because will call unlock_mntlist() properly anyway on exit.
 176    */
 177   setup_sighandler(SIGALRM, setlkw_timeout);
 178
 179   /* somewhat clumsy, but some ancient systems do not have snprintf() */
 180   /* use 20 as upper bound for the length of %d output */
 181   l = strlen(MOUNTLOCK_LINKTARGET) + 20;
 182   linktargetfile = xmalloc(l);
 183   xsnprintf(linktargetfile, l, MOUNTLOCK_LINKTARGET, getpid());
 184
 185   i = open(linktargetfile, O_WRONLY|O_CREAT, 0);
 186   if (i < 0) {
 187     int errsv = errno;
 188     /*
 189      * linktargetfile does not exist (as a file) and we cannot create
 190      * it. Read-only filesystem?  Too many files open in the system?
 191      * Filesystem full?
 192      */
 193     plog(XLOG_ERROR, "can't create lock file %s: %s (use -n flag to override)",
 194          linktargetfile, strerror(errsv));
 195   }
 196   close(i);
 197
 198
 199   /* Repeat until it was us who made the link */
 200   while (!we_created_lockfile) {
 201     struct flock flock;
 202     int errsv, j;
 203
 204     j = link(linktargetfile, MOUNTED_LOCK);
 205     errsv = errno;
 206
 207     if (j < 0 && errsv != EEXIST) {
 208       (void) unlink(linktargetfile);
 209       plog(XLOG_ERROR, "can't link lock file %s: %s ",
 210            MOUNTED_LOCK, strerror(errsv));
 211       return 0;
 212     }
 213
 214     lockfile_fd = open(MOUNTED_LOCK, O_WRONLY);
 215     if (lockfile_fd < 0) {
 216       int errsv = errno;
 217       /* Strange... Maybe the file was just deleted? */
 218       if (errno == ENOENT && tries-- > 0) {
 219         if (tries % 200 == 0)
 220           usleep(30);
 221         continue;
 222       }
 223       (void) unlink(linktargetfile);
 224       plog(XLOG_ERROR,"can't open lock file %s: %s ",
 225            MOUNTED_LOCK, strerror(errsv));
 226       return 0;
 227     }
 228
 229     flock.l_type = F_WRLCK;
 230     flock.l_whence = SEEK_SET;
 231     flock.l_start = 0;
 232     flock.l_len = 0;
 233
 234     if (j == 0) {
 235       /* We made the link. Now claim the lock. */
 236       if (fcntl(lockfile_fd, F_SETLK, &flock) == -1) {
 237         int errsv = errno;
 238         plog(XLOG_ERROR, "Can't lock lock file %s: %s",
 239              MOUNTED_LOCK, strerror(errsv));
 240         /* proceed, since it was us who created the lockfile anyway */
 241       }
 242       we_created_lockfile = 1;
 243       (void) unlink(linktargetfile);
 244     } else {
 245       static int tries = 0;
 246
 247       /* Someone else made the link. Wait. */
 248       alarm(LOCK_TIMEOUT);
 249
 250       if (fcntl(lockfile_fd, F_SETLKW, &flock) == -1) {
 251         int errsv = errno;
 252         (void) unlink(linktargetfile);
 253         plog(XLOG_ERROR, "can't lock lock file %s: %s",
 254              MOUNTED_LOCK, (errno == EINTR) ?
 255              "timed out" : strerror(errsv));
 256         return 0;
 257       }
 258       alarm(0);
 259       /*
 260        * Limit the number of iterations - maybe there
 261        * still is some old /etc/mtab~
 262        */
 263       ++tries;
 264       if (tries % 200 == 0)
 265         usleep(30);
 266       if (tries > 100000) {
 267         (void) unlink(linktargetfile);
 268         close(lockfile_fd);
 269         plog(XLOG_ERROR,
 270              "Cannot create link %s; Perhaps there is a stale lock file?",
 271              MOUNTED_LOCK);
 272       }
 273       close(lockfile_fd);
 274     }
 275   }
 276   return 1;
 277 }
 278
 279
 280 static FILE *
 281 open_locked_mtab(const char *mnttabname, char *mode, char *fs)
 282 {
 283   FILE *mfp = NULL;
 284
 285   if (mnt_file) {
 286     dlog("Forced close on %s in read_mtab", mnttabname);
 287     endmntent(mnt_file);
 288     mnt_file = NULL;
 289   }
 290
 291   if (!mtab_is_a_symlink() &&
 292       !lock_mtab()) {
 293     plog(XLOG_ERROR, "Couldn't lock mtab");
 294     return 0;
 295   }
 296
 297   mfp = setmntent((char *)mnttabname, mode);
 298   if (!mfp) {
 299     plog(XLOG_ERROR, "setmntent(\"%s\", \"%s\"): %m", mnttabname, mode);
 300     return 0;
 301   }
 302   return mfp;
 303 }
 304
 305
 306 /*
 307  * Unlock the mount table
 308  */
 309 void
 310 unlock_mntlist(void)
 311 {
 312   if (mnt_file || we_created_lockfile)
 313     dlog("unlock_mntlist: releasing");
 314   if (mnt_file) {
 315     endmntent(mnt_file);
 316     mnt_file = NULL;
 317   }
 318   if (we_created_lockfile) {
 319     close(lockfile_fd);
 320     lockfile_fd = -1;
 321     unlink(MOUNTED_LOCK);
 322     we_created_lockfile = 0;
 323   }
 324 }
 325
 326
 327 /*
 328  * Write out a mount list
 329  */
 330 void
 331 rewrite_mtab(mntlist *mp, const char *mnttabname)
 332 {
 333   FILE *mfp;
 334   int error = 0;
 335   char tmpname[64];
 336   int retries;
 337   int tmpfd;
 338   char *cp;
 339   char mcp[128];
 340
 341   if (!mtab_is_writable()) {
 342     return;
 343   }
 344
 345   /*
 346    * Concoct a temporary name in the same directory as the target mount
 347    * table so that rename() will work.
 348    */
 349   xstrlcpy(mcp, mnttabname, sizeof(mcp));
 350   cp = strrchr(mcp, '/');
 351   if (cp) {
 352     memmove(tmpname, mcp, cp - mcp);
 353     tmpname[cp - mcp] = '\0';
 354   } else {
 355     plog(XLOG_WARNING, "No '/' in mtab (%s), using \".\" as tmp directory", mnttabname);
 356     tmpname[0] = '.';
 357     tmpname[1] = '\0';
 358   }
 359   xstrlcat(tmpname, "/mtabXXXXXX", sizeof(tmpname));
 360   retries = 0;
 361  enfile1:
 362 #ifdef HAVE_MKSTEMP
 363   tmpfd = mkstemp(tmpname);
 364   fchmod(tmpfd, 0644);
 365 #else /* not HAVE_MKSTEMP */
 366   mktemp(tmpname);
 367   tmpfd = open(tmpname, O_RDWR | O_CREAT | O_TRUNC, 0644);
 368 #endif /* not HAVE_MKSTEMP */
 369   if (tmpfd < 0) {
 370     if (errno == ENFILE && retries++ < NFILE_RETRIES) {
 371       sleep(1);
 372       goto enfile1;
 373     }
 374     plog(XLOG_ERROR, "%s: open: %m", tmpname);
 375     return;
 376   }
 377   if (close(tmpfd) < 0)
 378     plog(XLOG_ERROR, "Couldn't close tmp file descriptor: %m");
 379
 380   retries = 0;
 381  enfile2:
 382   mfp = setmntent(tmpname, "w");
 383   if (!mfp) {
 384     if (errno == ENFILE && retries++ < NFILE_RETRIES) {
 385       sleep(1);
 386       goto enfile2;
 387     }
 388     plog(XLOG_ERROR, "setmntent(\"%s\", \"w\"): %m", tmpname);
 389     error = 1;
 390     goto out;
 391   }
 392   while (mp) {
 393     if (mp->mnt) {
 394       if (addmntent(mfp, mp->mnt)) {
 395         plog(XLOG_ERROR, "Can't write entry to %s", tmpname);
 396         error = 1;
 397         goto out;
 398       }
 399     }
 400     mp = mp->mnext;
 401   }
 402
 403   /*
 404    * SunOS 4.1 manuals say that the return code from entmntent()
 405    * is always 1 and to treat as a void.  That means we need to
 406    * call fflush() to make sure the new mtab file got written.
 407    */
 408   if (fflush(mfp)) {
 409     plog(XLOG_ERROR, "flush new mtab file: %m");
 410     error = 1;
 411     goto out;
 412   }
 413   (void) endmntent(mfp);
 414
 415   /*
 416    * Rename temporary mtab to real mtab
 417    */
 418   if (rename(tmpname, mnttabname) < 0) {
 419     plog(XLOG_ERROR, "rename %s to %s: %m", tmpname, mnttabname);
 420     error = 1;
 421     goto out;
 422   }
 423  out:
 424   if (error)
 425     (void) unlink(tmpname);
 426 }
 427
 428
 429 static void
 430 mtab_stripnl(char *s)
 431 {
 432   do {
 433     s = strchr(s, '\n');
 434     if (s)
 435       *s++ = ' ';
 436   } while (s);
 437 }
 438
 439
 440 /*
 441  * Append a mntent structure to the
 442  * current mount table.
 443  */
 444 void
 445 write_mntent(mntent_t *mp, const char *mnttabname)
 446 {
 447   int retries = 0;
 448   FILE *mfp;
 449
 450   if (!mtab_is_writable()) {
 451     return;
 452   }
 453
 454  enfile:
 455   mfp = open_locked_mtab(mnttabname, "a", mp->mnt_dir);
 456   if (mfp) {
 457     mtab_stripnl(mp->mnt_opts);
 458     if (addmntent(mfp, mp))
 459       plog(XLOG_ERROR, "Couldn't write %s: %m", mnttabname);
 460     if (fflush(mfp))
 461       plog(XLOG_ERROR, "Couldn't flush %s: %m", mnttabname);
 462     (void) endmntent(mfp);
 463   } else {
 464     if (errno == ENFILE && retries < NFILE_RETRIES) {
 465       sleep(1);
 466       goto enfile;
 467     }
 468     plog(XLOG_ERROR, "setmntent(\"%s\", \"a\"): %m", mnttabname);
 469   }
 470
 471   unlock_mntlist();
 472 }
 473
 474 #endif /* MOUNT_TABLE_ON_FILE */
 475
 476
 477 static mntent_t *
 478 mnt_dup(mntent_t *mp)
 479 {
 480   mntent_t *new_mp = ALLOC(mntent_t);
 481
 482   new_mp->mnt_fsname = strdup(mp->mnt_fsname);
 483   new_mp->mnt_dir = strdup(mp->mnt_dir);
 484   new_mp->mnt_type = strdup(mp->mnt_type);
 485   new_mp->mnt_opts = strdup(mp->mnt_opts);
 486
 487   new_mp->mnt_freq = mp->mnt_freq;
 488   new_mp->mnt_passno = mp->mnt_passno;
 489
 490 #ifdef HAVE_MNTENT_T_MNT_TIME
 491 # ifdef HAVE_MNTENT_T_MNT_TIME_STRING
 492   new_mp->mnt_time = strdup(mp->mnt_time);
 493 # else /* not HAVE_MNTENT_T_MNT_TIME_STRING */
 494   new_mp->mnt_time = mp->mnt_time;
 495 # endif /* not HAVE_MNTENT_T_MNT_TIME_STRING */
 496 #endif /* HAVE_MNTENT_T_MNT_TIME */
 497
 498 #ifdef HAVE_MNTENT_T_MNT_CNODE
 499   new_mp->mnt_cnode = mp->mnt_cnode;
 500 #endif /* HAVE_MNTENT_T_MNT_CNODE */
 501
 502   return new_mp;
 503 }
 504
 505
 506 /*
 507  * Read a mount table into memory
 508  */
 509 mntlist *
 510 read_mtab(char *fs, const char *mnttabname)
 511 {
 512   mntlist **mpp, *mhp;
 513
 514   mntent_t *mep;
 515
 516   FILE *mfp = open_locked_mtab(mnttabname, "r+", fs);
 517
 518   if (!mfp)
 519     return 0;
 520
 521   mpp = &mhp;
 522
 523   /*
 524    * XXX - In SunOS 4 there is (yet another) memory leak
 525    * which loses 1K the first time getmntent is called.
 526    * (jsp)
 527    */
 528   while ((mep = getmntent(mfp))) {
 529     /*
 530      * Allocate a new slot
 531      */
 532     *mpp = ALLOC(struct mntlist);
 533
 534     /*
 535      * Copy the data returned by getmntent
 536      */
 537     (*mpp)->mnt = mnt_dup(mep);
 538
 539     /*
 540      * Move to next pointer
 541      */
 542     mpp = &(*mpp)->mnext;
 543   }
 544   *mpp = NULL;
 545
 546 #ifdef MOUNT_TABLE_ON_FILE
 547   /*
 548    * If we are not updating the mount table then we
 549    * can free the resources held here, otherwise they
 550    * must be held until the mount table update is complete
 551    */
 552   mnt_file = mfp;
 553 #else /* not MOUNT_TABLE_ON_FILE */
 554   endmntent(mfp);
 555 #endif /* not MOUNT_TABLE_ON_FILE */
 556
 557   return mhp;
 558 }