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     { 80,       0,      "i2o/hd",       ENTRY_TYPE_DISC,        0,      4 },
00095     { 88,       0,      "hd",           ENTRY_TYPE_DISC,        12,     6 },
00096     { 89,       0,      "hd",           ENTRY_TYPE_DISC,        14,     6 },
00097     { 90,       0,      "hd",           ENTRY_TYPE_DISC,        16,     6 },
00098     { 91,       0,      "hd",           ENTRY_TYPE_DISC,        18,     6 },
00099     { 94,       0,      "dasd",         ENTRY_TYPE_DISC,        0,      2 },
00100     { 98,       0,      "ubd",          ENTRY_TYPE_DISC,        0,      4 },
00101     { 104,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       0,      4 },
00102     { 105,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       1,      4 },
00103     { 106,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       2,      4 },
00104     { 107,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       3,      4 },
00105     { 108,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       4,      4 },
00106     { 109,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       5,      4 },
00107     { 110,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       6,      4 },
00108     { 111,      0,      "cciss",        ENTRY_TYPE_DISC_ARRAY_CONTROLLER,       7,      4 },
00109     { 114,      0,      "ataraid",      ENTRY_TYPE_DISC_ARRAY,  0,      4 },
00110     { 0,        0,      NULL,           ENTRY_TYPE_ONE,         0,      0 },
00111   };
00112 
00113   struct stat s;
00114   struct entry *e;
00115 
00116   ssize_t ret = 0;
00117 
00118   unsigned int disc;
00119   unsigned int part;
00120 
00121   if (!strcmp ("none", path))
00122     return snprintf (buf, n, "%s", path);
00123 
00124   if (stat (path,&s) == -1)
00125     return 0;
00126 
00127   e = entries;
00128   while (e->name != NULL) {
00129     if (major (s.st_rdev) == e->major && 
00130         ((e->type == ENTRY_TYPE_ONE && minor (s.st_rdev) == e->minor) ||
00131          (e->type != ENTRY_TYPE_ONE && minor (s.st_rdev) >= e->minor))) {
00132       break;
00133     }
00134     e++;
00135   }
00136   if (!e->name) {
00137 #ifdef TEST
00138     fprintf(stderr, "(unknown device)\n");
00139 #endif
00140     /* Pass unknown devices on without changes. */
00141     return snprintf (buf, n, "%s", path);
00142   }
00143   
00144   strcat (buf, "/dev/");
00145 
00146   switch (e->type)
00147   {
00148     case ENTRY_TYPE_ONE:
00149       ret = di_snprintfcat (buf, n, "%s", e->name);
00150       break;
00151 
00152     case ENTRY_TYPE_NUMBER:
00153       disc = minor (s.st_rdev) - e->minor + e->entry_first;
00154 
00155       ret = di_snprintfcat (buf, n, "%s%d", e->name, disc);
00156       break;
00157 
00158     case ENTRY_TYPE_DISC:
00159     case ENTRY_TYPE_DISC_ARRAY:
00160     case ENTRY_TYPE_DISC_ARRAY_CONTROLLER:
00161       disc = (minor (s.st_rdev) >> e->entry_disc_minor_shift);
00162       part = (minor (s.st_rdev) & ((1 << e->entry_disc_minor_shift) - 1));
00163 
00164       switch (e->type)
00165       {
00166         case ENTRY_TYPE_DISC:
00167           disc += e->entry_first;
00168 
00169           if (disc + 'a' > 'z')
00170           {
00171             disc -= 26;
00172             ret = di_snprintfcat (buf, n, "%s%c%c", e->name, 'a' + disc / 26, 'a' + disc % 26);
00173           }
00174           else
00175             ret = di_snprintfcat (buf, n, "%s%c", e->name, 'a' + disc);
00176 
00177           if (part)
00178             ret = di_snprintfcat (buf, n, "%d", part);
00179 
00180           break;
00181         case ENTRY_TYPE_DISC_ARRAY:
00182         case ENTRY_TYPE_DISC_ARRAY_CONTROLLER:
00183           ret = di_snprintfcat (buf, n, "%s/", e->name);
00184           if (e->type == ENTRY_TYPE_DISC_ARRAY_CONTROLLER)
00185             ret = di_snprintfcat (buf, n, "c%d", e->entry_first);
00186           ret = di_snprintfcat (buf, n, "d%d", disc);
00187 
00188           if (part)
00189             ret = di_snprintfcat (buf, n, "p%d", part);
00190 
00191           break;
00192         default:
00193           break;
00194       }
00195       break;
00196   };
00197   
00198   return ret;
00199 }


Generated on Sat Sep 29 08:45:17 2007 for libdebian-installer by  doxygen 1.5.1