Each device node under /dev has its own major/minor number pair. I know that we can retrieve this pair of numbers from the device node by means of stat, like this:

stat -c 'major: %t minor: %T' <file>

Or, ls -l also shows these numbers.

But how can we get device node(s) by given major and minor numbers? The only way I'm aware of is some kind of ls -l + awk trick, but I really hope there is better solution.

  • @mikeserv, yes I know that some devices can share these numbers, so in my initial question I've mentioned: "get device node(s)". Ideally I want to get a list with all device nodes whose major/minor numbers match, one node per line. That's strange we don't have a ready tool for that. Thanks for the answer btw! Commented Aug 23, 2014 at 20:21

6 Answers 6


I found a simpler approach using the sys pseudofilesystem, at /sys/dev you have the devices ordered by type an then by major/minor, the file uevent contains the device name and a bunch of other info.

So for example,

  for file in $(find /sys/dev/ -name 7:0); do  
      source ${file}/uevent; echo $DEVNAME;



Note: This was tested in Debian Wheezy

  • to find backwards from dev name: for file in $(ls /sys/dev/block/ ); do source /sys/dev/block/${file}/uevent; if [ "$DEVNAME" == "sda1" ] ; then echo ${file}; fi done;
    – BBK
    Commented Jan 23, 2015 at 21:03

Apparently it can be done more simply with udevadm, and I've just found out how.

To get the DEVNAME from udevadm you need only do:

udevadm info -rq name $PATH

For instance, if you wanted to know the /dev name for /sys/dev/char/5:1 you'd do:

udevadm info -rq name /sys/dev/char/5:1



The -r option is to specify a --rooted path - without it the result above would read only console. The -q option specifies a database --query and it takes the operand name here - because we want the DEVNAME.

A very simple means of finding the path to a char and/or block device given only the major:minor numbers might look like:

mmdev() for d in /sys/dev/[cb]*/$1:$2
        do  [ -e "$d" ] || return
            printf %c:%s: "${d#/*/*/}" "${d##*/}"
            udevadm info -rq name "$d"

So running:

mmdev 8 0



Here's the first one I wrote.

majminpath() {
    set -- ${1##*[!0-9]*} ${2##*[!0-9]*}
    udevadm info --export-db |
    sed 's|^[^=]*DEVNAME=||

This just scans udevadm info --export-db output for the matching numbers. The output looks like:

P: /devices/virtual/vc/vcsa4
N: vcsa4
E: DEVNAME=/dev/vcsa4
E: DEVPATH=/devices/virtual/vc/vcsa4
E: MINOR=132

P: /devices/virtual/vc/vcsa5
N: vcsa5
E: DEVNAME=/dev/vcsa5
E: DEVPATH=/devices/virtual/vc/vcsa5
E: MINOR=133

#...and so on

The workflow is like:

  • attempt to strip the [^=]*DEVNAME= string from the head of each line

  • if a line does not have a first character or its first character is / copy that line over hold space

  • if a line matches MAJOR= append Next input line to pattern space

  • if there are 2 lines in pattern space that match =$1\n.*=$2$ then copy hold space over pattern space and auto-print; else delete pattern space

So if I do:

majminpath 7 133 ; majminpath 8 0 ; majminpath 8 1



But, as @xae points out, block/char type devices can share maj:min combinations, and so this might possibly print more than one path per call.

  • 1
    Unfortunately it's no so easy, a block and a character device can share the same major number. Take a look at the file /proc/devices.
    – xae
    Commented Aug 23, 2014 at 19:55
  • I gotta check subsystem - that's right. Thanks, @xae.
    – mikeserv
    Commented Aug 23, 2014 at 20:03

Not sure what you mean.

mknod foo b 8 0

Will create the device file called foo as a block device with major 8 and minor 0. If you mean to find one or any of the files in /dev that have the same type, major and minor, you can do (with zsh):

  • For block device 8:0:

    $ zmodload zsh/stat
    $ ls -ld /dev/**/*(-D%be:'zstat -H s $REPLY && (($s[rdev] == 8<<8+0))':)
    lrwxrwxrwx 1 root root    6 Aug 23 05:28 /dev/block/8:0 -> ../sda
    lrwxrwxrwx 1 root root    9 Aug 23 05:28 /dev/disk/by-id/ata-KINGSTON_SNV455S234GB_07MA10014418 -> ../../sda
    brw-rw---- 1 root disk 8, 0 Aug 23 05:28 /dev/sda
  • for char device 226:0:

    $ ls -ld /dev/**/*(-D%ce:'zstat -H s $REPLY && (($s[rdev] == 226<<8+0))':)
    lrwxrwxrwx  1 root root      12 Aug 23 05:28 /dev/char/226:0 -> ../dri/card0
    crw-rw----+ 1 root video 226, 0 Aug 23 05:28 /dev/dri/card0

Note that anything can create files in /dev. In the very old days, it was a script creating static files in there. At some point, you even had a special file system à la /proc.

On modern versions of Linux, it's usually udev based on input from the kernel.

The name it chooses for the base device file is based on the DEVNAME supplied by the kernel. udev rules may change that but generally don't, and some udev rules will add some more symlinks for convenience (like the /dev/disk/by... ones).

You can go from major:minor to kernel DEVNAME by looking at:

$ sed -n 's/^DEVNAME=//p' /sys/dev/block/8:0/uevent
$ sed -n 's/^DEVNAME=//p' /sys/dev/char/226:0/uevent

You can also get that information from the udev database as mikeserv has shown.


Alas, the /sys/dev hierachy was only added to the kernel as late as 2.6.27 (cf. the relevant commit against the kernel codebase), so we need a “bifurcated” approach.

Let $M and $m, respectively, be the major and minor number of our device file.

Post 2.6.27 kernels

As suggested by others, the simplest approach unleashes the power of the sysfs “virtual” file system, by chasing straight for files named $M:$m under the folder /sys/dev (more than one file is to be expected if we don't know whether our device is a character- or a block-based one), and then sourcing the uevent file (in a subshell so as to prevent namespace pollution):

for file in $(find /sys/dev/ -name $M:$m)
        source ${file}/uevent
        echo $DEVNAME

Pre 2.6.27 kernels

Let us assume, for simplicity's sake, that our file is a block device (a similar approach applies for character devices). We will search for the string $M:$m throughout the /sys/block hierarchy, by examining (underneath that folder) the contents of every file whose name happens to be dev. If /sys/block/<...>/<DEV>/dev is one such file, then DEV is bound to be our device's name:

dirname "$(find "/sys/block" -name dev | xargs -r grep -l ^$M:$m$)"

On Linux it is possible to take advantage of certain files in /proc virtual filesystem.

$ grep '8[[:blank:]]\+1[[:blank:]]\+' /proc/partitions 
   8        1   29309568 sda1

$ grep '8:1[[:blank:]]' /proc/self/mountinfo 
28 0 8:1 / / rw,relatime shared:1 - ext4 /dev/sda1 rw,data=ordered

The simple form of the pattern already provides information about the desired device in the output, however additional filtering to extract just one particular string is possible as well.


There is a library function: makedev()

#include <sys/sysmacros.h>
dev_t makedev(unsigned int maj, unsigned int min);

Given major and minor device IDs, makedev() combines these to produce a device ID, returned as the function result.

For more details visit: http://man7.org/linux/man-pages/man3/major.3.html

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .