DevFS
[System]


Functions

ssize_t di_system_devfs_map_from (const char *path, char *ret, size_t len)
ssize_t di_mapdevfs (const char *path, char *ret, size_t len) __attribute__((deprecated))

Function Documentation

ssize_t di_mapdevfs const char *  path,
char *  ret,
size_t  len
 

Deprecated:
Alias of di_system_devfs_map_from

ssize_t di_system_devfs_map_from const char *  path,
char *  ret,
size_t  len
 

Maps a devfs path to the corresponding standard dev path

Parameters:
path an existing device
ret device
len len of ret
00042 {
00043   static struct entry
00044   {
00045     unsigned char major;
00046     unsigned char minor;
00047     char *name;
00048     enum { ENTRY_TYPE_ONE, ENTRY_TYPE_NUMBER, ENTRY_TYPE_DISC, ENTRY_TYPE_DISC_ARRAY, ENTRY_TYPE_DISC_ARRAY_CONTROLLER } type;
00049     unsigned char entry_first;
00050     unsigned char entry_disc_minor_shift;
00051   }
00052   entries[] =
00053   {
00054     /*
00055       major     minor   name            type                    entry_first
00056                                                                         entry_disc_minor_shift
00057     */
00058     { 2,        0,      "fd",           ENTRY_TYPE_NUMBER,      0,      0 },
00059     { 3,        0,      "hd",           ENTRY_TYPE_DISC,        0,      6 },
00060     { 4,        64,     "ttyS",         ENTRY_TYPE_NUMBER,      0,      0 },
00061     { 4,        0,      "tty",          ENTRY_TYPE_NUMBER,      0,      0 },
00062     { 7,        0,      "loop",         ENTRY_TYPE_NUMBER,      0,      0 },
00063     { 8,        0,      "sd",           ENTRY_TYPE_DISC,        0,      4 },
00064     { 9,        0,      "md",           ENTRY_TYPE_NUMBER,      0,      0 },
00065     { 11,       0,      "scd",          ENTRY_TYPE_NUMBER,      0,      0 },
00066     { 22,       0,      "hd",           ENTRY_TYPE_DISC,        2,      6 },
00067     { 33,       0,      "hd",           ENTRY_TYPE_DISC,        4,      6 },
00068     { 34,       0,      "hd",           ENTRY_TYPE_DISC,        6,      6 },
00069     { 48,       0,      "rd",           ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       0,      3 },
00070     { 49,       0,      "rd",           ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       1,      3 },
00071     { 50,       0,      "rd",           ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       2,      3 },
00072     { 51,       0,      "rd",           ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       3,      3 },
00073     { 52,       0,      "rd",           ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       4,      3 },
00074     { 53,       0,      "rd",           ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       5,      3 },
00075     { 54,       0,      "rd",           ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       6,      3 },
00076     { 55,       0,      "rd",           ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       7,      3 },
00077     { 56,       0,      "hd",           ENTRY_TYPE_DISC,        8,      6 },
00078     { 57,       0,      "hd",           ENTRY_TYPE_DISC,        10,     6 },
00079     { 65,       0,      "sd",           ENTRY_TYPE_DISC,        16,     4 },
00080     { 66,       0,      "sd",           ENTRY_TYPE_DISC,        32,     4 },
00081     { 67,       0,      "sd",           ENTRY_TYPE_DISC,        48,     4 },
00082     { 68,       0,      "sd",           ENTRY_TYPE_DISC,        64,     4 },
00083     { 69,       0,      "sd",           ENTRY_TYPE_DISC,        80,     4 },
00084     { 70,       0,      "sd",           ENTRY_TYPE_DISC,        96,     4 },
00085     { 71,       0,      "sd",           ENTRY_TYPE_DISC,        112,    4 },
00086     { 72,       0,      "ida",          ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       0,      4 },
00087     { 73,       0,      "ida",          ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       1,      4 },
00088     { 74,       0,      "ida",          ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       2,      4 },
00089     { 75,       0,      "ida",          ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       3,      4 },
00090     { 76,       0,      "ida",          ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       4,      4 },
00091     { 77,       0,      "ida",          ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       5,      4 },
00092     { 78,       0,      "ida",          ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       6,      4 },
00093     { 79,       0,      "ida",          ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       7,      4 },
00094     { 88,       0,      "hd",           ENTRY_TYPE_DISC,        12,     6 },
00095     { 89,       0,      "hd",           ENTRY_TYPE_DISC,        14,     6 },
00096     { 90,       0,      "hd",           ENTRY_TYPE_DISC,        16,     6 },
00097     { 91,       0,      "hd",           ENTRY_TYPE_DISC,        18,     6 },
00098     { 94,       0,      "dasd",         ENTRY_TYPE_DISC,        0,      2 },
00099     { 98,       0,      "ubd",          ENTRY_TYPE_DISC,        0,      4 },
00100     { 104,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       0,      4 },
00101     { 105,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       1,      4 },
00102     { 106,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       2,      4 },
00103     { 107,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       3,      4 },
00104     { 108,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       4,      4 },
00105     { 109,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       5,      4 },
00106     { 110,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       6,      4 },
00107     { 111,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       7,      4 },
00108     { 114,      0,      "ataraid",      ENTRY_TYPE_DISC_ARRAY,  0,      4 },
00109     { 0,        0,      NULL,           ENTRY_TYPE_ONE,         0,      0 },
00110   };
00111 
00112   struct stat s;
00113   struct entry *e;
00114 
00115   ssize_t ret = 0;
00116 
00117   unsigned int disc;
00118   unsigned int part;
00119 
00120   if (!strcmp ("none", path))
00121     return snprintf (buf, n, "%s", path);
00122 
00123   if (stat (path,&s) == -1)
00124     return 0;
00125 
00126   e = entries;
00127   while (e->name != NULL) {
00128     if (major (s.st_rdev) == e->major && 
00129         ((e->type == ENTRY_TYPE_ONE && minor (s.st_rdev) == e->minor) ||
00130          (e->type != ENTRY_TYPE_ONE && minor (s.st_rdev) >= e->minor))) {
00131       break;
00132     }
00133     e++;
00134   }
00135   if (!e->name) {
00136 #ifdef TEST
00137     fprintf(stderr, "(unknown device)\n");
00138 #endif
00139     /* Pass unknown devices on without changes. */
00140     return snprintf (buf, n, "%s", path);
00141   }
00142   
00143   strcat (buf, "/dev/");
00144 
00145   switch (e->type)
00146   {
00147     case ENTRY_TYPE_ONE:
00148       ret = di_snprintfcat (buf, n, "%s", e->name);
00149       break;
00150 
00151     case ENTRY_TYPE_NUMBER:
00152       disc = minor (s.st_rdev) - e->minor + e->entry_first;
00153 
00154       ret = di_snprintfcat (buf, n, "%s%d", e->name, disc);
00155       break;
00156 
00157     case ENTRY_TYPE_DISC:
00158     case ENTRY_TYPE_DISC_ARRAY:
00159     case ENTRY_TYPE_DISC_ARRAY_CONTROLLER:
00160       disc = (minor (s.st_rdev) >> e->entry_disc_minor_shift);
00161       part = (minor (s.st_rdev) & ((1 << e->entry_disc_minor_shift) - 1));
00162 
00163       switch (e->type)
00164       {
00165         case ENTRY_TYPE_DISC:
00166           disc += e->entry_first;
00167 
00168           if (disc + 'a' > 'z')
00169           {
00170             disc -= 26;
00171             ret = di_snprintfcat (buf, n, "%s%c%c", e->name, 'a' + disc / 26, 'a' + disc % 26);
00172           }
00173           else
00174             ret = di_snprintfcat (buf, n, "%s%c", e->name, 'a' + disc);
00175 
00176           if (part)
00177             ret = di_snprintfcat (buf, n, "%d", part);
00178 
00179           break;
00180         case ENTRY_TYPE_DISC_ARRAY:
00181         case ENTRY_TYPE_DISC_ARRAY_CONTROLLER:
00182           ret = di_snprintfcat (buf, n, "%s/", e->name);
00183           if (e->type == ENTRY_TYPE_DISC_ARRAY_CONTROLLER)
00184             ret = di_snprintfcat (buf, n, "c%d", e->entry_first);
00185           ret = di_snprintfcat (buf, n, "d%d", disc);
00186 
00187           if (part)
00188             ret = di_snprintfcat (buf, n, "p%d", part);
00189 
00190           break;
00191         default:
00192           break;
00193       }
00194       break;
00195   };
00196   
00197   return ret;
00198 }


Generated on Mon Jan 16 16:19:21 2006 for libdebian-installer by  doxygen 1.4.6