sysdeps/unix/sysv/linux/shm_open.c

   1 /* Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, write to the Free
  16    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  17    02111-1307 USA.  */
  18
  19 #include <errno.h>
  20 #include <fcntl.h>
  21 #include <mntent.h>
  22 #include <paths.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <sys/mman.h>
  28 #include <sys/statfs.h>
  29 #include <bits/libc-lock.h>
  30 #include "linux_fsinfo.h"
  31
  32
  33 /* Mount point of the shared memory filesystem.  */
  34 static struct
  35 {
  36   char *dir;
  37   size_t dirlen;
  38 } mountpoint;
  39
  40 /* This is the default directory.  */
  41 static const char defaultdir[] = "/dev/shm/";
  42
  43 /* Protect the `mountpoint' variable above.  */
  44 __libc_once_define (static, once);
  45
  46
  47 /* Determine where the shmfs is mounted (if at all).  */
  48 static void
  49 where_is_shmfs (void)
  50 {
  51   char buf[512];
  52   struct statfs f;
  53   struct mntent resmem;
  54   struct mntent *mp;
  55   FILE *fp;
  56
  57   /* The canonical place is /dev/shm.  This is at least what the
  58      documentation tells everybody to do.  */
  59   if (__statfs (defaultdir, &f) == 0 && f.f_type == SHMFS_SUPER_MAGIC)
  60     {
  61       /* It is in the normal place.  */
  62       mountpoint.dir = (char *) defaultdir;
  63       mountpoint.dirlen = sizeof (defaultdir) - 1;
  64
  65       return;
  66     }
  67
  68   /* OK, do it the hard way.  Look through the /proc/mounts file and if
  69      this does not exist through /etc/fstab to find the mount point.  */
  70   fp = __setmntent ("/proc/mounts", "r");
  71   if (__builtin_expect (fp == NULL, 0))
  72     {
  73       fp = __setmntent (_PATH_MNTTAB, "r");
  74       if (__builtin_expect (fp == NULL, 0))
  75         /* There is nothing we can do.  Blind guesses are not helpful.  */
  76         return;
  77     }
  78
  79   /* Now read the entries.  */
  80   while ((mp = __getmntent_r (fp, &resmem, buf, sizeof buf)) != NULL)
  81     /* The original name is "shm" but this got changed in early Linux
  82        2.4.x to "tmpfs".  */
  83     if (strcmp (mp->mnt_type, "tmpfs") == 0
  84         || strcmp (mp->mnt_type, "shm") == 0)
  85       {
  86         /* Found it.  There might be more than one place where the
  87            filesystem is mounted but one is enough for us.  */
  88         size_t namelen;
  89
  90         /* First make sure this really is the correct entry.  At least
  91            some versions of the kernel give wrong information because
  92            of the implicit mount of the shmfs for SysV IPC.  */
  93         if (__statfs (mp->mnt_dir, &f) != 0 || f.f_type != SHMFS_SUPER_MAGIC)
  94           continue;
  95
  96         namelen = strlen (mp->mnt_dir);
  97
  98         if (namelen == 0)
  99           /* Hum, maybe some crippled entry.  Keep on searching.  */
 100           continue;
 101
 102         mountpoint.dir = (char *) malloc (namelen + 2);
 103         if (mountpoint.dir != NULL)
 104           {
 105             char *cp = __mempcpy (mountpoint.dir, mp->mnt_dir, namelen);
 106             if (cp[-1] != '/')
 107               *cp++ = '/';
 108             *cp = '\0';
 109             mountpoint.dirlen = cp - mountpoint.dir;
 110           }
 111
 112         break;
 113       }
 114
 115   /* Close the stream.  */
 116   __endmntent (fp);
 117 }
 118
 119
 120 /* Open shared memory object.  This implementation assumes the shmfs
 121    implementation introduced in the late 2.3.x kernel series to be
 122    available.  Normally the filesystem will be mounted at /dev/shm but
 123    we fall back on searching for the actual mount point should opening
 124    such a file fail.  */
 125 int
 126 shm_open (const char *name, int oflag, mode_t mode)
 127 {
 128   size_t namelen;
 129   char *fname;
 130   int fd;
 131
 132   /* Determine where the shmfs is mounted.  */
 133   __libc_once (once, where_is_shmfs);
 134
 135   /* If we don't know the mount points there is nothing we can do.  Ever.  */
 136   if (mountpoint.dir == NULL)
 137     {
 138       __set_errno (ENOSYS);
 139       return -1;
 140     }
 141
 142   /* Construct the filename.  */
 143   while (name[0] == '/')
 144     ++name;
 145
 146   if (name[0] == '\0')
 147     {
 148       /* The name "/" is not supported.  */
 149       __set_errno (EINVAL);
 150       return -1;
 151     }
 152
 153   namelen = strlen (name);
 154   fname = (char *) alloca (mountpoint.dirlen + namelen + 1);
 155   __mempcpy (__mempcpy (fname, mountpoint.dir, mountpoint.dirlen),
 156              name, namelen + 1);
 157
 158   /* And get the file descriptor.
 159      XXX Maybe we should test each descriptor whether it really is for a
 160      file on the shmfs.  If this is what should be done the whole function
 161      should be revamped since we can determine whether shmfs is available
 162      while trying to open the file, all in one turn.  */
 163   fd = open (fname, oflag | O_NOFOLLOW, mode);
 164   if (fd != -1)
 165     {
 166       /* We got a descriptor.  Now set the FD_CLOEXEC bit.  */
 167       int flags = fcntl (fd, F_GETFD, 0);
 168
 169       if (__builtin_expect (flags, 0) >= 0)
 170         {
 171           flags |= FD_CLOEXEC;
 172           flags = fcntl (fd, F_SETFD, flags);
 173         }
 174
 175       if (flags == -1)
 176         {
 177           /* Something went wrong.  We cannot return the descriptor.  */
 178           int save_errno = errno;
 179           close (fd);
 180           fd = -1;
 181           __set_errno (save_errno);
 182         }
 183     }
 184
 185   return fd;
 186 }
 187
 188
 189 /* Unlink a shared memory object.  */
 190 int
 191 shm_unlink (const char *name)
 192 {
 193   size_t namelen;
 194   char *fname;
 195
 196   /* Determine where the shmfs is mounted.  */
 197   __libc_once (once, where_is_shmfs);
 198
 199   if (mountpoint.dir == NULL)
 200     {
 201       /* We cannot find the shmfs.  If `name' is really a shared
 202          memory object it must have been created by another process
 203          and we have no idea where that process found the mountpoint.  */
 204       __set_errno (ENOENT);
 205       return -1;
 206     }
 207
 208   /* Construct the filename.  */
 209   while (name[0] == '/')
 210     ++name;
 211
 212   if (name[0] == '\0')
 213     {
 214       /* The name "/" is not supported.  */
 215       __set_errno (ENOENT);
 216       return -1;
 217     }
 218
 219   namelen = strlen (name);
 220   fname = (char *) alloca (mountpoint.dirlen + namelen + 1);
 221   __mempcpy (__mempcpy (fname, mountpoint.dir, mountpoint.dirlen),
 222              name, namelen + 1);
 223
 224   /* And remove the file.  */
 225   return unlink (fname);
 226 }
 227
 228
 229 static void  __attribute__ ((unused))
 230 freeit (void)
 231 {
 232   if (mountpoint.dir != defaultdir)
 233     free (mountpoint.dir);
 234 }
 235
 236
 237 /* Make sure the table is freed if we want to free everything before
 238    exiting.  */
 239 text_set_element (__libc_subfreeres, freeit);