if ((oflag & O_CREAT) != 0)
if ((oflag & O_CREAT) != 0 && errno == ENOENT)
sem_open (const char *name, int oflag, ...){  char *finalname;  size_t namelen;  sem_t *result = SEM_FAILED;  int fd;  /* Determine where the shmfs is mounted.  */  INTUSE(__pthread_once) (&__namedsem_once, __where_is_shmfs);  /* If we don't know the mount points there is nothing we can do.  Ever.  */  if (mountpoint.dir == NULL)    {      __set_errno (ENOSYS);      return SEM_FAILED;    }  /* Construct the filename.  */  while (name[0] == '/')    ++name;  if (name[0] == '\0')    {      /* The name "/" is not supported.  */      __set_errno (EINVAL);      return SEM_FAILED;    }  namelen = strlen (name);  /* Create the name of the final file.  */  finalname = (char *) alloca (mountpoint.dirlen + namelen + 1);  __mempcpy (__mempcpy (finalname, mountpoint.dir, mountpoint.dirlen),	     name, namelen + 1);  /* If the semaphore object has to exist simply open it.  */  if ((oflag & O_CREAT) == 0 || (oflag & O_EXCL) == 0)    {    try_again:      fd = __libc_open (finalname,			(oflag & ~(O_CREAT|O_ACCMODE)) | O_NOFOLLOW | O_RDWR);      if (fd == -1)	{	  /* If we are supposed to create the file try this next.  */	  if ((oflag & O_CREAT) != 0)	    goto try_create;	  /* Return.  errno is already set.  */	}      else	/* Map the sem_t structure from the file.  */	result = (sem_t *) mmap (NULL, sizeof (sem_t), PROT_READ | PROT_WRITE,				 MAP_SHARED, fd, 0);    }  else    {      /* We have to open a temporary file first since it must have the	 correct form before we can start using it.  */      char *tmpfname;      mode_t mode;      unsigned int value;      va_list ap;    try_create:      va_start (ap, oflag);      mode = va_arg (ap, mode_t);      value = va_arg (ap, unsigned int);      va_end (ap);      if (value > SEM_VALUE_MAX)	{	  __set_errno (EINVAL);	  return SEM_FAILED;	}      tmpfname = (char *) alloca (mountpoint.dirlen + 6 + 1);      strcpy (__mempcpy (tmpfname, mountpoint.dir, mountpoint.dirlen),	      "XXXXXX");      fd = mkstemp (tmpfname);      if (fd == -1)	return SEM_FAILED;      /* Create the initial file content.  */      sem_t initsem;      struct sem *iinitsem = (struct sem *) &initsem;      iinitsem->count = value;      /* Initialize the remaining bytes as well.  */      memset ((char *) &initsem + sizeof (struct sem), '\0',	      sizeof (sem_t) - sizeof (struct sem));      if (TEMP_FAILURE_RETRY (__libc_write (fd, &initsem, sizeof (sem_t)))	  == sizeof (sem_t)	  /* Adjust the permission.  */	  && fchmod (fd, mode) == 0	  /* Map the sem_t structure from the file.  */	  && (result = (sem_t *) mmap (NULL, sizeof (sem_t),				       PROT_READ | PROT_WRITE, MAP_SHARED,				       fd, 0)) != MAP_FAILED)	{	  /* Create the file.  Don't overwrite an existing file.  */	  if (link (tmpfname, finalname) != 0)	    {	      /* Undo the mapping.  */	      (void) munmap (result, sizeof (sem_t));	      /* Reinitialize 'result'.  */	      result = SEM_FAILED;	      /* This failed.  If O_EXCL is not set and the problem was		 that the file exists, try again.  */	      if ((oflag & O_EXCL) == 0 && errno == EEXIST)		{		  /* Remove the file.  */		  (void) unlink (tmpfname);		  /* Close the file.  */		  (void) __libc_close (fd);		  goto try_again;		}	    }	}      /* Now remove the temporary name.  This should never fail.  If	 it fails we leak a file name.  Better fix the kernel.  */      (void) unlink (tmpfname);    }  /* Map the mmap error to the error we need.  */  if (MAP_FAILED != (void *) SEM_FAILED && result == MAP_FAILED)    result = SEM_FAILED;  /* We don't need the file descriptor anymore.  */  if (fd != -1)    (void) __libc_close (fd);  return result;}