Device-mapper to libdevmapper protocol
		


  1) Device mapper device in a POV of LVM it is an Logical Volume. 
     Logical Volume is virtual block device is made from logical blocks.
     These blocks are mapped to real device blocks with algorithm called 
     target.
     
     Functions available to dm device:
     	       create, remove, list, status of device.

  2) device mapper target is function which  defines how are Logical blocks 
     mapped to physical. There are many targets linear, stripe, mirror etc.

     Functions available to dm device:
     	       list available targets. They can be added with module in linux.

  3) dm table.
     Every device-mapper device consists from one or more tables.
     Table specifies start, length of logical blocks and target which is used
     to map them to physical blocks.

     {start} {length} {target} | {device} {target parameters}
     
     after | are target specific parameters listed. 

     Functions available to dm device:
     	       load, unload, table_status.


   List of available ioct calls
   
   DM_VERSION
   DM_REMOVE_ALL
   DM_LIST_DEVICES
   DM_DEV_CREATE
   DM_DEV_REMOVE
   DM_DEV_RENAME
   DM_DEV_SUSPEND
   DM_DEV_STATUS
   DM_DEV_WAIT
   DM_TABLE_LOAD
   DM_TABLE_CLEAR
   DM_TABLE_DEPS
   DM_TABLE_STATUS
   DM_LIST_VERSIONS
   DM_TARGET_MSG   
   DM_DEV_SET_GEOMETRY    

   1) DM_VERSION 

      in: struct dm-ioctl

      out: struct dm-ioctl

      Function:
	 sends libdevmapper ioctl protocol version to kernel and ask for kernel version.
	 If major and minor numbers are good we can continue.

   2) DM_REMOVE_ALL
      
      in: none

      out: none

      Function:
	This ioctl will remove all DM devices/tables from DM driver.

  3) DM_LIST_DEVICES
     
     in: none
	
     out: List of structures describing all devices created in driver.

     Function: 
       List all devices created in driver. (linux use struct dm_name_list)

     Implementation:
       Kernel driver will place list of struct dm_name_list behind 
       struct dm_ioctl in userspace. Kernel driver will list through
       the all devices and copyout info about them.

  4) DM_DEV_CREATE
     
     in: struct dm-ioctl(name/uuid)

     out: none

     Function:
       Create device in dm driver, with specified name/uuid(uuid is preferred). 
       (linux use struct dm_name_list)
       
 5) DM_DEV_REMOVE
     
    in: struct dm-ioctl(name/uuid)

    out: none

    Function:
      Remove device from dm driver list, also remove device tables.

 6) DM_DEV_RENAME
    
    in: struct dm-ioctl(name/uuid) and string found after dm-ioctl struct in buffer

    out: none

    Function:
      Rename device from name to string.

    Implementation:
       Kernel driver will find device with name from struct dm_ioctl-name/uuid.
       Change name of selected device to string found behind struct dm_ioctl header 
       in userspace buffer.

 7) DM_DEV_SUSPEND
    
    in: dm-ioctl(name/uuid)

    out: none

    Function: 
      Suspend all io's  on device, after this ioctl. Already started io's will be done.
      Newer can't be started.

 8) DM_DEV_STATUS

    in: dm-ioctl(name/uuid)

    out: dm-ioctl (minor,open_count,target_count)

    Function: 
      Return status info about selected device

    Implementation:
       Kernel driver will find device with name from struct dm_ioctl-name/uuid.
       Change values minor,open_count,target_count in dm_ioctl struct for 
       selected device.

 9) DM_DEV_WAIT

    in: dm-ioctl(name/uuid)

    out: none

    Function: 
      Wait for device event to happen.

 10) DM_TABLE_LOAD

     in: dm-ioctl(name/uuid),table specification

     out: none
 
     Function: 
       Load table to selected device. Table is loaded to unused slot and than switched.
       (linux use struct dm_target_spec)
       
     Implementation:
       Kernel driver will find device with name from struct dm_ioctl-name/uuid.
       Table is added to the inactive slot. Every device can have more than one 
       table loaded. Tables are stored in SLIST. This ioctl also open physical 
       device specified in table and add it to dm_device specific pdev list.

 11) DM_TABLE_CLEAR

     in: dm-ioctl(name/uuid)

     out: none

     Function: 
       Remove table from unused slot. 

 12) DM_TABLE_DEPS

     in: dm-ioctl(name/uuid)

     out: list of dependencies devices

     Function: 
       Return set of device dependencies e.g. mirror device for mirror target etc..

 13) DM_TABLE_STATUS

     in: dm-ioctl(name/uuid)

     out: list of used tables from selected devices (linux use struct dm_target_spec)

     Function: 
       List all tables in active slot in device with name name/uuid.       

     Implementation:
       Kernel driver will find device with name from struct dm_ioctl-name/uuid.
       DM driver will copyout dm_target_spec structures behind struct dm_ioctl.

 14) DM_LIST_VERSIONS	
     
     in: none

     out: list of all targets in device-mapper driver (linux use struct dm_target_versions)

     Function:
       List all available targets to libdevmapper.

     Implementation:
       Kernel driver will copy out known target versions.

 15) DM_TARGET_MSG
     
     in: message to driver (linux use struct dm_target_msg)

     out: none

     Function:
      Send message to kernel driver target.
     

 16) DM_DEV_SET_GEOMETRY

     Function:
       Set geometry of device-mapper driver.


	    	NetBSD device-mapper driver implementation
		
   device-mapper devices -> devs dm_dev.c

   This entity is created with DM_DEV_CREATE ioctl, and stores info 
   about every device in device mapper driver. It has two slots for 
   active and inactive table, list of active physical devices added 
   to this device and list of upcalled devices (for targets which use
   more than one physical device e.g. mirror, snapshot etc..).

   device-mapper physical devices -> pdevs dm_pdev.c

   This structure contains opened device VNODES. Because I physical 
   device can be found in more than one table loaded to different 
   dm devices. When device is destroyed I decrement all reference 
   counters for all added pdevs (I remove pdevs with ref_cnt == 0).

   device-mapper tables -> table  dm_table.c, dm_ioctl.c
   
   Table describe how is dm device made. What blocks are mapped with 
   what target. In our implementation every table contains pointer to
   target specific config data. These config_data are allocated in 
   DM_TABLE_LOAD function with target_init routine. Every table 
   contains pointer to used target.

   device-mapper targets -> target dm_target.c
   
   Target describes mapping of logical blocks to physical. It has 
   function pointers to function which does init, strategy, destroy,
   upcall functions.

   P.S I want to thank reinod@ for great help and guidance :).
   
	

		Design of new device-mapper ioctl interface

   Basic architecture of device-mapper -> libdevmapper ioctl interface is this. 
   Libdevmapper allocate buffer with size of data_size. At the start of this buffer 
   dm-ioctl structure is placed. any additional information from/to kernel are placed
   behind end (start of data part is pointed with data_start var.) of dm-ioctl struct. 
   
   Kernel driver then after ioctl call have to copyin data from userspace to kernel.
   When kernel driver want to send data back to user space library it must copyout 
   data from kernel.

1) In Linux device-mapper ioctl interface implementation there are these ioctls.

   DM_VERSION                 *
   DM_REMOVE_ALL	      
   DM_LIST_DEVICES	      *
   DM_DEV_CREATE	      *
   DM_DEV_REMOVE	      *
   DM_DEV_RENAME	      *
   DM_DEV_SUSPEND	      
   DM_DEV_STATUS	      *
   DM_DEV_WAIT		      
   DM_TABLE_LOAD	      *
   DM_TABLE_CLEAR	      *
   DM_TABLE_DEPS	      
   DM_TABLE_STATUS	      *
   DM_LIST_VERSIONS	      *
   DM_TARGET_MSG   
   DM_DEV_SET_GEOMETRY

* means implemented in current version of NetBSD device-mapper.

  1a) struct dm_ioctl based ioctl calls
        These ioctl calls communicate only with basic dm_ioctl structure. 
	
	  DM_VERSION
  	  DM_DEV_STATUS
	  DM_DEV_CREATE	  

  Protocol structure:
	  
  struct dm_ioctl {
	uint32_t version[3];	/* device-mapper kernel/userspace version */
	uint32_t data_size;	/* total size of data passed in
				 * including this struct */

	uint32_t data_start;	/* offset to start of data
				 * relative to start of this struct */

	uint32_t target_count;	/* in/out */ /* This should be set when DM_TABLE_STATUS is called */
	int32_t  open_count;	/* device open count */
	uint32_t flags;		/* information flags  */
        uint32_t event_nr;      /* event counters not implemented */
	uint32_t padding;

	uint64_t dev;		/* dev_t */

	char name[DM_NAME_LEN];	/* device name */
	char uuid[DM_UUID_LEN];	/* unique identifier for
				 * the block device */

        void *user_space_addr;  /*this is needed for netbsd 
				  because they differently 
				  implement ioctl syscall*/
  };

 As SOC task I want to replace this structure with proplib dict. Proplib dict 
 basic structure should be:

 Note: I don't need data_star, data_size and use_space_addr. They are needed 
       for current implementation. 

       <dict>
               <key>version</key>
               <string>...</string>

               <key>target_count</key>
	       <integer></integer>

               <key>open_count</key>
	       <integer></integer>

               <key>flags</key>
	       <integer></integer>

               <key>event_nr</key>
	       <integer></integer>

	       <key>dev</key>
	       <integer></integer>
	       
	       <key>name</key>
               <string>...</string>

               <key>uuid</key>
               <string>...</string>


	       <dict>
	        <!-- ioctl specific data -->
	       </dict>
       </dict>

    1b) DM_LIST_VERSIONS ioctl

    This ioctl is used to get list of supported targets from kernel. Target 
    define mapping of Logical blocks to physical blocks on real device.
    There are linear, zero, error, mirror, snapshot, multipath etc... targets.

    For every target kernel driver should copyout this structure to userspace.

    Protocol structure:

    struct dm_target_versions {
        uint32_t next;
        uint32_t version[3];

        char name[0];
    };

    Because I need more than one dm_target_version I will need one major proplib 
    dictionary to store children dictionaries with target data.

    <dict>
        <dict ID="id">
	   <key>version</key>
           <string>...</string>	

	   <key>name</key>
	   <string>...</string>	
	</dict>
    </dict>

    2a) DM_LIST_DEVICES 
    
    This ioctl is used to list all devices defined in kernel driver. 

    Protocol structure:
    
    struct dm_name_list {
        uint64_t dev;
        uint32_t next;          /* offset to the next record from
                                   the _start_ of this */
        char name[0];
    };

    Again because I can have more than one device in kernel driver I need one parent 
    dictionary and more children dictionaries.

        <dict>
          <dict ID="id">
	   <key>dev</key>
           <integer>...</integer>	

	   <key>name</key>
	   <string>...</string>	
	  </dict>
        </dict>
	
   2b) DM_DEV_RENAME 
      This ioctl is called when libdevmapper want to rename device-mapper device.
      Libdevmapper library appends null terminated string to dm_ioctl struct in 
      userspace..
      
      <dict>
            <key>name</key>
      	    <string>...</string>
      </dict>
      
   2c) DM_DEV_CREATE, DM_DEV_REMOVE, DM_DEV_STATUS 
       Modify only dm_ioctl structure so I don't need to specify new structures.


  3a) DM_TABLE_LOAD, DM_TABLE_STATUS
      DM_TABLE_LOAD ioctl loads table to device. DM_TABLE_STATUS send info about 
      every table for selected device to userspace. Table is different for every 
      target basic table structure is this 

      {start} {length} {target} {additional information}

      e.g. 
      0 100 zero 

      0 100 linear /dev/wdba 384      

      Protocol structure:

      struct dm_target_spec {
        uint64_t sector_start;
        uint64_t length;
        int32_t status;         /* used when reading from kernel only */

        uint32_t next;

        char target_type[DM_MAX_TYPE_NAME];
        
        /*
         * Parameter string starts immediately after this object.
         * Be careful to add padding after string to ensure correct
         * alignment of subsequent dm_target_spec.
	 */
      };

      <dict>
	<key>sector_start</key>
	<integer>...</integer>

	<key>length</key>
	<integer>...</integer>

	<key>target_type</key>
	<string>...</string>
	
	<key>additional info</key>
	<string>...</string>
      </dict>