libdevinfo man page on SmartOS

Man page or keyword search:  
man Server   16655 pages
apropos Keyword Search (all sections)
Output format
SmartOS logo
[printable version]


       libdevinfo - device information library

       cc [ flag... ] file... -ldevinfo [ library... ]
       #include <libdevinfo.h>

       Functions in this library access device configuration information.

       Device  configuration  data  is	organized  as  a tree of device nodes,
       defined as di_node_t in the libdevinfo interfaces. Each di_node_t  rep‐
       resents	a physical or logical (pseudo) device. The types of data asso‐
       ciated with device nodes are:

	   o	  data defined for all device nodes (attributes)

	   o	  data defined for all multipath path nodes

	   o	  data defined for all minor node data

	   o	  properties specific to nodes

       All device nodes have a set of common attributes, such as a node	 name,
       an  instance  number,  and  a  driver  binding name. Common device node
       attributes are accessed by calling interfaces listed  on	 the  di_bind‐
       ing_name(3DEVINFO)  manual  page.  Each device node also has a physical
       path, which is accessed by calling di_devfs_path(3DEVINFO).

       Properties provide device specific information for device configuration
       and  usage.  Properties	can  be	 defined by software (di_prop_t) or by
       firmware (di_prom_prop_t). One way to access each di_prop_t is to  make
       successive   calls   to	di_prop_next(3DEVINFO)	until  DI_PROP_NIL  is
       returned. For each di_prop_t, use interfaces on the di_prop_bytes(3DEV‐
       INFO)  manual page to obtain property names and values.	Another way to
       access these properties is to  call  di_prop_lookup_bytes(3DEVINFO)  to
       find   the  value  of  a	 property  with	 a  given  name.  Accessing  a
       di_prom_prop_t is similar to accessing a	 di_prop_t,  except  that  the
       interface  names	 start	with  di_prom_prop  and	 additional  calls  to
       di_prom_init(3DEVINFO) and di_prom_fini(3DEVINFO) are required.

       Minor nodes contain information exported by  the	 device	 for  creating
       special	files  for  the	 device.  Each device node has 0 or more minor
       nodes associated with it. A list of minor  nodes	 (di_minor_t)  can  be
       obtained	 by  making  successive calls to di_minor_next(3DEVINFO) until
       DI_MINOR_NIL is returned. For each minor node,  di_minor_devt(3DEVINFO)
       and related interfaces are called to get minor node data.

       In some configurations, multipath device access via a virtual host con‐
       troller interface (vHCI) abstraction  is	 possible.  An	example	 of  a
       driver  using this abstraction is scsi_vhci(7D). In such cases, devices
       are not directly represented as children of their  physical  host  con‐
       troller	interface  (pHCI)  bus adapter. Instead, devices have an iden‐
       tity-oriented representation as a child of a vHCI. All paths leading to
       the  same  identity  are	 represented by a common child endpoint of the
       vHCI called the "client" device node. The vHCI virtualizes access among
       the  underlying	pHCI physical paths. The underlying connection between
       vHCI-managed client endpoints and the pHCI paths to  that  endpoint  is
       represented by a class of nodes called "path" nodes (di_path_t).

       Each  path  node	 is  associated with two device nodes: its pHCI device
       node, and its client device node. A list of  paths  associated  with  a
       specific	    pHCI     device	node	can    be    obtained	 using
       di_path_phci_next_path(3DEVINFO), and a list of paths associated with a
       specific	    client    device	node	can    be    obtained	 using
       di_path_client_next_path(3DEVINFO). These functions return  DI_PATH_NIL
       when the end of the list of path nodes is reached.

       For  each path node, di_path_state(3DEVINFO) and related interfaces are
       called to get path node data.

       Using libdevinfo involves three steps:

	   o	  Creating a snapshot of the device tree

	   o	  Traversing the device tree to get information of interest

	   o	  Destroying the snapshot of the device tree

       A snapshot of the device tree is created by  calling  di_init(3DEVINFO)
       and  destroyed by calling di_fini(3DEVINFO). An application can specify
       the data to be included in the snapshot (full or partial tree,  include
       or  exclude properties and minor nodes) and get a handle to the root of
       the device tree.	 See di_init(3DEVINFO) for  details.  The  application
       then traverses the device tree in the snapshot to obtain device config‐
       uration data.

       The device tree	is  normally  traversed	 through  parent-child-sibling
       linkage.	  Each device node contains references to its parent, its next
       sibling, and the first of its children. Given  the  di_node_t  returned
       from   di_init(),   one	 can   find  all  children  by	first  calling
       di_child_node(3DEVINFO),	 followed  by  successive  calls  to   di_sib‐
       ling_node(3DEVINFO)  until  DI_NODE_NIL	is returned. By following this
       procedure recursively, an application can visit all device  nodes  con‐
       tained  in  the snapshot. Two interfaces,The di_walk_node(3DEVINFO) and
       di_walk_minor(3DEVINFO) functions are  provided	to  facilitate	device
       tree traversal. The di_walk_node() function visits all device nodes and
       executes a user-supplied callback function for each node	 visited.  The
       di_walk_minor()	function  does	the  same  for	each minor node in the
       device tree.

       An alternative way to traverse the device  tree	is  through  the  per-
       driver  device  node  linkage.  Device nodes contain a reference to the
       next device node bound to the same driver. Given the di_node_t returned
       from  di_init(),	 an  application  can find all device nodes bound to a
       driver by first calling di_drv_first_node(3DEVINFO), followed  by  suc‐
       cessive	 calls	to  di_drv_next_node(3DEVINFO)	until  DI_NODE_NIL  is
       returned.  Traversing the per-driver device node list works  only  when
       the snapshot includes all device nodes.

       See  di_init(3DEVINFO)  for  examples  of libdevinfo usage. See Writing
       Device Drivers for information about Solaris device configuration.

       The  shared  object  provides  the  public  interfaces
       defined below. See Intro(3) for additional information on shared object

       di_binding_name		     di_bus_addr
       di_child_node		     di_compatible_names
       di_devfs_minor_path	     di_devfs_path
       di_devfs_path_free	     di_devid
       di_driver_major		     di_driver_name
       di_driver_ops		     di_drv_first_node
       di_drv_next_node		     di_fini
       di_init			     di_instance
       di_link_next_by_lnode	     di_link_next_by_node
       di_link_private_get	     di_link_private_set
       di_link_spectype		     di_link_to_lnode
       di_lnode_devinfo		     di_lnode_devt
       di_lnode_name		     di_lnode_next
       di_lnode_private_get	     di_lnode_private_set
       di_minor_devt		     di_minor_name
       di_minor_next		     di_minor_nodetype
       di_minor_private_get	     di_minor_private_set
       di_minor_spectype	     di_minor_type
       di_node_name		     di_node_private_get
       di_node_private_set	     di_nodeid
       di_parent_node		     di_path_bus_addr
       di_path_client_devfs_path     di_path_client_next_path
       di_path_client_node	     di_path_devfs_path
       di_path_instance		     di_path_node_name
       di_path_phci_next_path	     di_path_phci_node
       di_path_prop_bytes	     di_path_prop_int64s
       di_path_prop_ints	     di_path_prop_len
       di_path_prop_lookup_bytes     di_path_prop_lookup_int64s
       di_path_prop_lookup_ints	     di_path_prop_lookup_strings
       di_path_prop_name	     di_path_prop_strings
       di_path_prop_next	     di_path_prop_type
       di_path_state		     di_prom_fini
       di_prom_init		     di_prom_prop_data
       di_prom_prop_lookup_bytes     di_prom_prop_lookup_ints
       di_prom_prop_lookup_strings   di_prom_prop_name
       di_prom_prop_next	     di_prop_bytes
       di_prop_devt		     di_prop_int64
       di_prop_ints		     di_prop_lookup_bytes
       di_prop_lookup_int64	     di_prop_lookup_ints
       di_prop_lookup_strings	     di_prop_name
       di_prop_next		     di_prop_strings
       di_prop_type		     di_sibling_node
       di_state			     di_walk_link
       di_walk_lnode		     di_walk_minor

       Example 1 Information accessible through libdevinfo interfaces

       The following example illustrates the kind  of  information  accessible
       through	libdevinfo  interfaces	for  a device node representing a hard
       disk (sd2):

	     node name:	 sd
	     instance:	 2
	     physical path:  /sbus@1f,0/espdma@e,8400000/esp@e,8800000/sd@2,0


	 Minor nodes
	     (disk partition /dev/dsk/c0t2d0s0)
		 name:	     a
		 dev_t:	     0x0080010 (32/16)
		 spectype:   IF_BLK (block special)
	     (disk partition /dev/rdsk/c0t2d0s2)
		 name:	     c,raw
		 dev_t:	     0x0080012 (32/18)
		 spectype:   IF_CHR (character special)


	   shared object


	   64-bit shared object

       See attributes(5) for descriptions of the following attributes:

       │Interface Stability │ Committed	      │
       │MT-Level	    │ Safe	      │

       pvs(1), devlinks(1M), prtconf(1M), Intro(3), di_binding_name(3DEVINFO),
       di_child_node(3DEVINFO),	  di_devfs_path(3DEVINFO),  di_init(3DEVINFO),
       di_minor_devt(3DEVINFO),			      di_minor_next(3DEVINFO),
       di_path_bus_addr(3DEVINFO),	   di_path_client_next_path(3DEVINFO),
       di_path_prop_bytes(3DEVINFO),	  di_path_prop_lookup_bytes(3DEVINFO),
       di_path_prop_next(3DEVINFO),		       di_prom_init(3DEVINFO),
       di_prop_bytes(3DEVINFO),		       di_prop_lookup_bytes(3DEVINFO),
       di_prop_next(3DEVINFO),	 di_walk_minor(3DEVINFO),   di_walk_node(3DEV‐
       INFO), attributes(5)

       Writing Device Drivers

				 May 15, 2008		      LIBDEVINFO(3LIB)

List of man pages available for SmartOS

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net