Main Page | Modules | Data Structures | File List | Data Fields | Related Pages

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


Generated on Wed Nov 17 19:42:59 2004 for libdebian-installer by  doxygen 1.3.9.1