Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  1 
  2 #include <linux/kernel.h>
  3 #include <linux/dirent.h>
  4 #include <linux/string.h>
  5 
  6 #include "do_mounts.h"
  7 
  8 void __init mount_devfs(void)
  9 {
 10         sys_mount("devfs", "/dev", "devfs", 0, NULL);
 11 }
 12 
 13 void __init umount_devfs(char *path)
 14 {
 15         sys_umount(path, 0);
 16 }
 17 
 18 /*
 19  * If the dir will fit in *buf, return its length.  If it won't fit, return
 20  * zero.  Return -ve on error.
 21  */
 22 static int __init do_read_dir(int fd, void *buf, int len)
 23 {
 24         long bytes, n;
 25         char *p = buf;
 26         sys_lseek(fd, 0, 0);
 27 
 28         for (bytes = 0; bytes < len; bytes += n) {
 29                 n = sys_getdents64(fd, (struct linux_dirent64 *)(p + bytes),
 30                                         len - bytes);
 31                 if (n < 0)
 32                         return n;
 33                 if (n == 0)
 34                         return bytes;
 35         }
 36         return 0;
 37 }
 38 
 39 /*
 40  * Try to read all of a directory.  Returns the contents at *p, which
 41  * is kmalloced memory.  Returns the number of bytes read at *len.  Returns
 42  * NULL on error.
 43  */
 44 static void * __init read_dir(char *path, int *len)
 45 {
 46         int size;
 47         int fd = sys_open(path, 0, 0);
 48 
 49         *len = 0;
 50         if (fd < 0)
 51                 return NULL;
 52 
 53         for (size = 1 << 9; size <= (PAGE_SIZE << MAX_ORDER); size <<= 1) {
 54                 void *p = kmalloc(size, GFP_KERNEL);
 55                 int n;
 56                 if (!p)
 57                         break;
 58                 n = do_read_dir(fd, p, size);
 59                 if (n > 0) {
 60                         sys_close(fd);
 61                         *len = n;
 62                         return p;
 63                 }
 64                 kfree(p);
 65                 if (n == -EINVAL)
 66                         continue;       /* Try a larger buffer */
 67                 if (n < 0)
 68                         break;
 69         }
 70         sys_close(fd);
 71         return NULL;
 72 }
 73 
 74 /*
 75  * recursively scan <path>, looking for a device node of type <dev>
 76  */
 77 static int __init find_in_devfs(char *path, unsigned dev)
 78 {
 79         char *end = path + strlen(path);
 80         int rest = path + 64 - end;
 81         int size;
 82         char *p = read_dir(path, &size);
 83         char *s;
 84 
 85         if (!p)
 86                 return -1;
 87         for (s = p; s < p + size; s += ((struct linux_dirent64 *)s)->d_reclen) {
 88                 struct linux_dirent64 *d = (struct linux_dirent64 *)s;
 89                 if (strlen(d->d_name) + 2 > rest)
 90                         continue;
 91                 switch (d->d_type) {
 92                         case DT_BLK:
 93                                 sprintf(end, "/%s", d->d_name);
 94                                 if (bstat(path) != dev)
 95                                         break;
 96                                 kfree(p);
 97                                 return 0;
 98                         case DT_DIR:
 99                                 if (strcmp(d->d_name, ".") == 0)
100                                         break;
101                                 if (strcmp(d->d_name, "..") == 0)
102                                         break;
103                                 sprintf(end, "/%s", d->d_name);
104                                 if (find_in_devfs(path, dev) < 0)
105                                         break;
106                                 kfree(p);
107                                 return 0;
108                 }
109         }
110         kfree(p);
111         return -1;
112 }
113 
114 /*
115  * create a device node called <name> which points to
116  * <devfs_name> if possible, otherwise find a device node
117  * which matches <dev> and make <name> a symlink pointing to it.
118  */
119 int __init create_dev(char *name, dev_t dev, char *devfs_name)
120 {
121         char path[64];
122 
123         sys_unlink(name);
124         if (devfs_name && devfs_name[0]) {
125                 if (strncmp(devfs_name, "/dev/", 5) == 0)
126                         devfs_name += 5;
127                 sprintf(path, "/dev/%s", devfs_name);
128                 if (sys_access(path, 0) == 0)
129                         return sys_symlink(devfs_name, name);
130         }
131         if (!dev)
132                 return -1;
133         strcpy(path, "/dev");
134         if (find_in_devfs(path, new_encode_dev(dev)) < 0)
135                 return -1;
136         return sys_symlink(path + 5, name);
137 }
138 
  This page was automatically generated by the LXR engine.