usr/src/lib/libc/port/gen/mkdev.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1988 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 #pragma ident   "%Z%%M% %I%     %E% SMI"
  31
  32 #include "lint.h"
  33 #include <sys/types.h>
  34 #include <sys/mkdev.h>
  35 #include <errno.h>
  36
  37 /*
  38  * Create a formatted device number
  39  */
  40 dev_t
  41 __makedev(const int version, const major_t majdev, const minor_t mindev)
  42 {
  43         dev_t devnum;
  44         switch (version) {
  45         case OLDDEV:
  46                 if (majdev > OMAXMAJ || mindev > OMAXMIN) {
  47                         errno = EINVAL;
  48                         return ((o_dev_t)NODEV);
  49                 }
  50                 devnum = ((majdev << ONBITSMINOR) | mindev);
  51                 break;
  52
  53         case NEWDEV:
  54 #if MAXMAJ != 0xfffffffful      /* assumes major_t == uint32_t */
  55                 if (majdev > MAXMAJ) {
  56                         errno = EINVAL;
  57                         return (NODEV);
  58                 }
  59 #endif
  60 #if MAXMIN != 0xfffffffful      /* assumes minor_t == uint32_t */
  61                 if (mindev > MAXMIN) {
  62                         errno = EINVAL;
  63                         return (NODEV);
  64                 }
  65 #endif
  66                 if ((devnum = (((dev_t)majdev << NBITSMINOR) |
  67                     mindev)) == NODEV) {
  68                         errno = EINVAL;
  69                         return (NODEV);
  70                 }
  71                 break;
  72
  73         default:
  74                 errno = EINVAL;
  75                 return (NODEV);
  76         }
  77
  78         return (devnum);
  79 }
  80
  81 /*
  82  * Return major number part of formatted device number
  83  */
  84 major_t
  85 __major(const int version, const dev_t devnum)
  86 {
  87         major_t maj;
  88
  89         switch (version) {
  90         case OLDDEV:
  91                 maj = (devnum >> ONBITSMINOR);
  92                 if (devnum == NODEV || maj > OMAXMAJ) {
  93                         errno = EINVAL;
  94                         return ((major_t)NODEV);
  95                 }
  96                 break;
  97
  98         case NEWDEV:
  99                 maj = (devnum >> NBITSMINOR);
 100                 if (devnum == NODEV) {
 101                         errno = EINVAL;
 102                         return ((major_t)NODEV);
 103                 }
 104 #if MAXMAJ != 0xfffffffful      /* assumes major_t == uint32_t */
 105                 if (maj > MAXMAJ) {
 106                         errno = EINVAL;
 107                         return ((major_t)NODEV);
 108                 }
 109 #endif
 110                 break;
 111
 112         default:
 113                 errno = EINVAL;
 114                 return ((major_t)NODEV);
 115         }
 116
 117         return (maj);
 118 }
 119
 120
 121 /*
 122  * Return minor number part of formatted device number
 123  */
 124 minor_t
 125 __minor(const int version, const dev_t devnum)
 126 {
 127         switch (version) {
 128         case OLDDEV:
 129                 if (devnum == NODEV) {
 130                         errno = EINVAL;
 131                         return ((minor_t)NODEV);
 132                 }
 133                 return (devnum & OMAXMIN);
 134
 135         case NEWDEV:
 136                 if (devnum == NODEV) {
 137                         errno = EINVAL;
 138                         return ((minor_t)NODEV);
 139                 }
 140                 return (devnum & MAXMIN);
 141
 142         default:
 143                 errno = EINVAL;
 144                 return ((minor_t)NODEV);
 145         }
 146 }