xenstore2

转载 2011年01月12日 00:17:00

XenStore 是一个类似于数据库的文件系统, 包含了domain间的共享信息. 有domain配置和状态信息.XenStore 提供了一种发现设备信息的简便方法. 它作为数据库在 /var/lib/xenstore/tdb, 在用户空间的 daemon 称为 "xenstored".这个逻辑文件树有三个主要的路径:

/vm - /vm/uuid 存储配置信息,例如虚拟CPU数和内存分配数.

/local/domain - 包含了正在运行的domain信息, 由domid标识.

/tool - 存储多种工具信息.

应用程序向这个数据库的 key 写信息, 配置驱动; 驱动在key上设置watch并对改变做出回应.

详细介绍请参考: http://wiki.xensource.com/xenwiki/XenStoreReference

访问xenstore

在guest kernel启动时xenstore经过start_info页而被访问到, 作为共享页的机器页帧号和event channel使用.Dom0工具使用UNIX domain socket /var/run/xenstored/socket 或 /var/run/xenstoed/socket_ro; Dom0工具使用proce接口/proc/xen/xenbus, 内核代码使用xenbus API.

命令

xenstore-read, xenstore-exists, xenstore-list, xenstor-, xsls, 用于和xenstored daemon数据库通信.
e.g. - #xenstore-list /local/domain/0

Domain 标识

1) 通用唯一标识符(UUID)是标识domain的数字, 即使guest迁移也保持相同.

2) domain 标识(DOMID) 标识一个正在运行的实例, 当guest 迁移到另一台机器后DOMID改变.

什么是Xenbus

Xenbus是Xenstore的一个接口, 它也是在Xenstore之上写的设备驱动的连接协议. Xenbus是一个虚拟设备的mgmt bus. Xen PV "backend" 设备出现在xenbus上, 而且能被DomU使用PV "fronted"设备驱动访问到. 这些虚拟后端设备的状态由xenbus管理. 这些状态被存储到xenstore, 并且一直被Dom0和DomU的xenbus驱动程序监测.XenStore 指供了一个domain如何将前端设备与后端提供的服务联系起来的方法, (实际这部分是由XenBus承载的, 一种建立在XenStore顶层的协议). 后端与前端通信使用共享event channel 和 ring buffer通信. 所有规范的xen虚拟设备驱动在初始化时向XenBus注册自己. 这是通过传递xenbus_driver 结构体给
xenbus_register_devide()函数.

代码

以下代码创建两个可执行的, xenstore-read 和 xenstore-write 程序.

在一个Dom中运行xenstore-read - 从 /loca/doman/X/memory/target 读取Domx的memory/target值.依赖于你运行这个程序所在的Dom.

在一个Dom中运行xenstore-wirte - 写一个memory/target值到这个程序所运行的Dom.

  1. // Example taken from wiki.xensource.com/xenwiki/XenStoreReference and some code added   
  2. //   
  3. // Compiled using   
  4. //        gcc -g xenstore.c -DREAD=1 -lxenstore -o xenstore-read   
  5. //        gcc -g xenstore.c -DWRITE=1 -lxenstore -o xenstore-write   
  6. //   
  7. // To change permissions on /local/domain/0, use   
  8. // xenstore-chod -r /local/domain/0 b  - for r and w   
  9. // xenstore-chod -r /local/domain/0 w  - for w   
  10. //   
  11. #include <sys/types.h>   
  12. #include <xs.h>   
  13. #include <stdio.h>   
  14. #include <string.h>   
  15. #include <malloc.h>   
  16. #include <sys/stat.h> // for lstat()   
  17. #include <stdlib.h> // for exit()   
  18. #define DOM0 0   
  19. #define DOMU 1   
  20. int  dom = 999;  
  21. // This function checks if the app is in domU or dom0. The /proc/xen/capabilities   
  22. // contains the string "control_d" if the app is in a dom0   
  23. //   
  24. // /sys/hypervisor/type can be checked too, to see if we are running on a xen   
  25. // hyervisor   
  26. check_dom()  
  27. {  
  28.     FILE  *file = NULL;  
  29.     char  *filePath;  
  30.     struct  stat linkAttrs;  
  31.     char  buf[100] =  "" ;  
  32.     filePath = "/proc/xen/capabilities" ;  
  33.     if  ((lstat(filePath, &linkAttrs)) != 0) {  
  34.         perror("lstat" );  
  35.         return ;  
  36.     }  
  37.     if  ((file = fopen( "/proc/xen/capabilities" "r" )) == NULL) {  
  38.         perror("fopen" );  
  39.         return ;  
  40.     }     
  41.     if  (!fgets(buf,  sizeof (buf), file)) {  
  42.         // we are in DomU, since the buffer is empty   
  43.         printf("/n Surely in DOMU, since capabilities is empty" );  
  44.         dom = DOMU;  
  45.         return ;  
  46.     } else  {  
  47.         // we are probably in Dom0   
  48.         printf("/n Probably in DOM0, since capabilities has some data" );  
  49.         dom = DOM0;  
  50.     }  
  51.     // the following is in case they change the capabilities to have some   
  52.     // data in a DomU   
  53.     if  ((strstr(buf,  "control_d" )) == NULL) {  
  54.         // we are in DomU   
  55.         printf("/n We are in DOMU" );  
  56.         dom = DOMU;  
  57.     } else  {  
  58.         // we are in Dom0   
  59.         printf("/n We are in DOM0" );  
  60.         dom = DOM0;  
  61.     }  
  62.     return ;  
  63. }  
  64. // xs_write is written outside a transaction. Else it does not work for me. Pass   
  65. // a XBT_NULL as a 2nd param to xs_write().   
  66. write_to_xenstore (struct  xs_handle *xs,  char * path) {  
  67.     char             somedata[8] = { "2200000" };  
  68.     xs_transaction_t    trans;  
  69.     bool             err;  
  70.     printf("/nWriting data %s of len %d to %s" ,  
  71.             somedata, strlen(somedata), path);  
  72.     // xs_write() -> xs_talkv()   
  73.     //    -> xs_write_all() -> write() - sys_write()   
  74.     //    -> xs_read_reply()   
  75.     err = xs_write(xs, XBT_NULL, path, &somedata[0],  
  76.                 strlen(somedata));  
  77.     if  (!err) {  
  78.         printf("/n Could'nt write var in xenstore" );  
  79.     }  
  80.     xs_daemon_close(xs);  
  81.     free(path);  
  82.     exit(0);  
  83. }  
  84. int  main( int  argc,  char  *argv[]) {  
  85.     struct  xs_handle    *xs;     // handle to xenstore   
  86.     xs_transaction_t    trans;  
  87.     char             *path;  
  88.     int             fd;  
  89.     fd_set            set;  
  90.     bool             err;  
  91.     struct  timeval tv = {.tv_sec = 0, .tv_usec = 0};  
  92.     char              **vec;  
  93.     unsigned int          num;  
  94.     char             *buf;  
  95.     char             **buf2;  
  96.     unsigned int         len, i;  
  97.     unsigned int         domid;  
  98.     // check if we are in Dom0 or DomU   
  99.     check_dom();  
  100.     // Connect to XenStore. From Dom0 we call xs_daemon_open,   
  101.     // and from DomU, we call xs_domain_open().    
  102.     // xs_daemon_open() -> get_handle(xs_daemon_socket()).   
  103.     // xs_daemon_socket()->xs_daemon_path() which returns   
  104.     // XENSTORED_PATH/socket. A get_handle() on the above path generates   
  105.     // a socket (PF_UNIX, SOCK_STREAM, 0) and connects to above socket.   
  106.     // For domU, connect to XenStore via xs_domain_open().   
  107.     // xs_domain_dev() returns path to /proc/xen/xenbus, and a   
  108.     // get_handle() on this returns a 'fd' to this file.   
  109.     if  (dom == DOMU) {  
  110.         xs = xs_domain_open(); // DomU   
  111.         if  (xs == NULL) error();  
  112.         buf = xs_read(xs, XBT_NULL, "domid" , &len);  
  113.         if  (!buf) {  
  114.             printf("/n Could not read domid" );  
  115.             return ;  
  116.         }  
  117.         domid = atoi(buf);  
  118.         printf("/n Retrieved Dom ID = %d/n" , domid);  
  119.     } else  {  
  120.         xs = xs_daemon_open();  // Dom0   
  121.         if  (xs == NULL) error();  
  122.         trans = xs_transaction_start(xs);  
  123.         if  (trans == 0) {  
  124.             printf("/n Could not start xaction with XS" );  return ;  
  125.         }  
  126.         // Get contents of a directory. Need to call free after use,   
  127.         // since the API mallocs memory   
  128.         buf2 = xs_directory(xs, trans, "/local/domain" , &len);  
  129.         if  (!buf2) {  
  130.             printf("/n Could not read XS dir /local/domain" );  return ;  
  131.         }  
  132.         xs_transaction_end(xs, trans, true );  
  133.         if  (trans == 0) {  
  134.             printf("/n Could not end xaction with XS" );  return ;  
  135.         }  
  136.         printf("/n Len of Dir /local/domain is %d" , len);  
  137.         printf("/n Dir Contents: " );  
  138.         for  (i=0; i<len;i++) { printf( "%s " , buf2[i]); }  
  139.         if  (len == 1) {  
  140.             // we have only 1 Dom running, i.e. Dom0   
  141.             domid = atoi(buf2[0]);  
  142.         } else   if  (len == 2) {  
  143.             domid = atoi(buf2[1]);  
  144.         }  
  145.         // Set domid to 0, since Dom0 is always id 0   
  146.         domid = 0;  
  147.         printf("/n Setting Dom ID = %d/n" , domid);  
  148.     }  
  149.     // Get the local Domain path in xenstore   
  150.     path = xs_get_domain_path(xs, domid);  
  151.     if  (path == NULL) {  
  152.         printf("/n Dom Path in Xenstore not found" );  
  153.         error(); return ;  
  154.     }  
  155.     // xs_directory has an implicit root at /local/domain/<domid> in DomU   
  156.     // and thus need to just pass "memory/target" if we are running this   
  157.     // from a DomU to read the directory's contents   
  158.     if  (dom == DOM0) {  
  159.         path = realloc(path, strlen(path) + strlen("/memory/target" ) + 1);  
  160.         if  (path == NULL) {  
  161.             error(); return ;  
  162.         }  
  163.         strcat(path, "/memory/target" );  
  164.     } else  {  
  165.         strcpy(path, "memory/target" );  
  166.     }  
  167.          
  168.     printf("/nPath = %s" , path);  
  169.      
  170.     // If we are doing a write to the xenstore, branch off here and   
  171.     // then exit from the program. Else for read, cary on, and do a   
  172.     // select() to wait for a change in watched values   
  173. #ifdef WRITE   
  174.     write_to_xenstore(xs, path);  
  175. #endif   
  176.     // Create a watch on the path   
  177.     err = xs_watch(xs, path, "mytoken" );  
  178.     if  (err == 0) {  
  179.         printf("/n Error in setting watch on mytoken in %s" , path);  
  180.         error(); return ;  
  181.     }  
  182.     // Watches are notified via a File Descriptor. We can POLL on this.   
  183.     fd = xs_fileno(xs);  
  184.     while  (1) {  
  185.         FD_ZERO(&set);  
  186.         FD_SET(fd, &set);  
  187.         printf("!-" );  
  188.         fflush(stdout);  
  189.         struct  timeval tv = {.tv_sec = 5, .tv_usec = 0};  
  190.         if  (select(fd+1, &set, NULL, NULL, &tv) > 0  
  191.             && FD_ISSET(fd, &set)) {  
  192.             printf("@" );  
  193.             // This blocks is nothing is pending. Returns an array   
  194.             // containing path and token. Use Xs_WATCH_* to   
  195.             // access these elements. Call free after use.   
  196.             vec = xs_read_watch(xs, &num);  
  197.             if  (!vec) {  
  198.                 printf("Error on watch firing" );  
  199.                 error(); return ;  
  200.             }  
  201.             // In our example code, the following will print out   
  202.             // /local/domain/0/memory/target|mytoken   
  203.             printf("/nvec contents: %s|%s/n" , vec[XS_WATCH_PATH],  
  204.                     vec[XS_WATCH_TOKEN]);  
  205.             // Prepare a transacation to do a read   
  206.             trans = xs_transaction_start(xs);  
  207.             if  (trans == 0) {  
  208.                 printf("/n Could'nt start xaction xenstore" );  
  209.                 return ;  
  210.             }  
  211.             buf = xs_read(xs, trans, vec[XS_WATCH_PATH], &len);  
  212.             if  (!buf) {  
  213.                 printf("/n Could'nt read watch var in vec" );  
  214.                 return ;  
  215.             }  
  216.             xs_transaction_end(xs, trans, true );  
  217.             if  (trans == 0) {  
  218.                 printf("/n Could not end xaction xenstore" );  
  219.                 return ;  
  220.             }  
  221.             if  (buf) {  
  222.                 printf("/n buflen: %d, buf: %s" , len, buf);  
  223.             }  
  224.         } // end of select   
  225.     } // end while(1)   
  226.     printf("/n" );  
  227.     // cleanup   
  228.     close(fd);  
  229.     xs_daemon_close(xs);  
  230.     free(path);  
  231.     return ;  
  232. }  

相关文章推荐

XenBus and XenStore

XenStore是一个类似于数据库的文件系统, 包含了domain间的共享信息. 有domain配置和状态信息.XenStore 提供了一种发现设备信息的简便方法. 它作为数据库在/var/lib/x...

xenstore

Xenstore 是主要的用来控制建立来自客户机的共享内存区域的事件通道、管理客户机的通知,收集客户机状态数据的工具。Xenstore 的目录是层次似的 key-data 值对。每个域都有一个目录继承...

XenStore

XenStore XenStore 是一种在Xen guest Domain间共享的存储系统,他是一个简单的分层储存结构,由Domain 0维护,并且通过共享存储页面和事件通道访问。尽管Xen...

XenStore: 使用,结构和原理

2.     xenstore结构和通信数据流程 XenStore结构   XenStore包含两个模块:Dom0用户空间的xenstored服务主模块,和Dom*里的Xen...
  • sdulibh
  • sdulibh
  • 2014年05月09日 19:08
  • 1428

XenStore:使用,结构和原理(3. XenStore启动过程分析)

摘要:XenStore的初始化完全在用户空间的libxl中实现。Dom0包办了所有的操作,使DomU一启动,就可以与Dom0进行xenstore通信,但是程序非常的复杂和难以维护。Xen核心仅仅为xe...

Ubuntu编译运行Redsocks2实现透明代理

redsocks1有bug,不能关闭已建立的连接,一旦超越linux的最大限制,就会报“Too many open files”异常,导致服务瘫痪,需要每隔一段时间进行重启 在我的使用还发现redso...

基于caffe的图像分类(2)——制作lmdb和计算均值

由于caffe-master\examples\imagenet中有生成lmdb和计算均值的脚本,所以,我们可以使用这些脚本。 我们将训练所用的图片文件夹放在image下,train.txt和va...

Python版的Word2Vec -- gensim 学习手札 中文词语相似性度量 V1.1

前言相关内容链接: 第一节:Google Word2vec 学习手札 昨天好不容易试用了一下Google自己提供的Word2Vector的源代码,花了好长时间训练数据,结果发现似乎Python并不能...
  • MebiuW
  • MebiuW
  • 2016年08月24日 20:10
  • 8780

[增强学习][Reinforcement Learning]学习笔记与回顾-2-马尔可夫决策过程MDP

Markov Decision Processes前言本文主要是视频学习的总结与回顾,想要了解更多内容请看视频或者学习专业课程。这一节主要是说马尔可夫决策过程-Markov Decision Proc...

nodejs koa2的基础使用

开发工具为VS Code 完成的需求是在浏览器输入http://localhost:3000/ 进入首页登录界面,输入登录密码后,跳转到登录成功页面,如下图 先进行分包,首先提前建立一个文件夹...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:xenstore2
举报原因:
原因补充:

(最多只允许输入30个字)