开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
kml_decode.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：35k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

kml_decode.c：源码内容
  1. /*
  2.  * KML Decoding
  3.  *
  4.  * Copryright (C) 1996 Arthur Ma <arthur.ma@mountainviewdata.com> 
  5.  *
  6.  * Copyright (C) 2001 Mountainview Data, Inc.
  7.  */
  8. #define __NO_VERSION__
  9. #include <linux/module.h>
  10. #include <linux/errno.h>
  11. #include <linux/kernel.h>
  12. #include <linux/major.h>
  13. #include <linux/slab.h>
  14. #include <linux/vmalloc.h>
  15. #include <linux/mm.h>
  16. #include <linux/intermezzo_fs.h>
  17. #include <linux/intermezzo_kml.h>
  19. static int size_round (int val);
  20. static int unpack_create (struct kml_create *rec, char *buf,
  21.                                 int pos, int *rec_offs);
  22. static int unpack_open (struct kml_open *rec, char *buf,
  23.                                 int pos, int *rec_offs);
  24. static int unpack_symlink (struct kml_symlink *rec, char *buf,
  25.                                 int pos, int *rec_offs);
  26. static int unpack_mknod (struct kml_mknod *rec, char *buf,
  27.                                 int pos, int *rec_offs);
  28. static int unpack_link (struct kml_link *rec, char *buf,
  29.                                 int pos, int *rec_offs);
  30. static int unpack_rename (struct kml_rename *rec, char *buf,
  31.                                 int pos, int *rec_offs);
  32. static int unpack_unlink (struct kml_unlink *rec, char *buf,
  33.                                 int pos, int *rec_offs);
  34. static int unpack_rmdir (struct kml_rmdir *rec, char *buf,
  35.                                 int pos, int *rec_offs);
  36. static int unpack_setattr (struct kml_setattr *rec, char *buf,
  37.                                 int pos, int *rec_offs);
  38. static int unpack_close (struct kml_close *rec, char *buf,
  39.                                 int pos, int *rec_offs);
  40. static int unpack_mkdir (struct kml_mkdir *rec, char *buf,
  41.                                 int pos, int *rec_offs);
  43. #if 0
  44. static int unpack_endmark (struct kml_endmark *rec, char *buf,
  45.                                 int pos, int *rec_offs);
  46. static void print_kml_endmark (struct kml_endmark *rec);
  47. #endif
  49. static int kml_unpack (char *kml_buf, int rec_size, int kml_offset,
  50.                         struct kml_rec **newrec);
  51. static char *kml_version (struct presto_version *ver);
  52. static void print_kml_prefix (struct big_journal_prefix *head);
  53. static void print_kml_create (struct kml_create *rec);
  54. static void print_kml_mkdir (struct kml_mkdir *rec);
  55. static void print_kml_unlink (struct kml_unlink *rec);
  56. static void print_kml_rmdir (struct kml_rmdir *rec);
  57. static void print_kml_close (struct kml_close *rec);
  58. static void print_kml_symlink (struct kml_symlink *rec);
  59. static void print_kml_rename (struct kml_rename *rec);
  60. static void print_kml_setattr (struct kml_setattr *rec);
  61. static void print_kml_link (struct kml_link *rec);
  62. static void print_kml_mknod (struct kml_mknod *rec);
  63. static void print_kml_open (struct kml_open *rec);
  64. static void print_kml_suffix (struct journal_suffix *tail);
  65. static char *readrec (char *recbuf, int reclen, int pos, int *size);
  67. #define  KML_PREFIX_WORDS           8
  68. static int kml_unpack (char *kml_buf, int rec_size, int kml_offset, 
  69.                         struct kml_rec **newrec)
  70. {
  71.         struct kml_rec  *rec;
  72.         char            *p;
  73.         int             pos, rec_offs;
  74.         int             error;
  76.         ENTRY;
  77.         if (rec_size < sizeof (struct journal_prefix) +
  78.                        sizeof (struct journal_suffix))
  79.                 return -EBADF;
  81.         PRESTO_ALLOC(rec, struct kml_rec *, sizeof (struct kml_rec));
  82.         if (rec == NULL) {
  83.                 EXIT;
  84.                 return -ENOMEM;
  85.         }
  86.         rec->rec_kml_offset = kml_offset;
  87.         rec->rec_size = rec_size;
  88.         p = kml_buf;
  89.         p = dlogit (&rec->rec_head, p, KML_PREFIX_WORDS * sizeof (int));
  90.         p = dlogit (&rec->rec_head.groups, p, 
  91.                         sizeof (int) * rec->rec_head.ngroups);
  93.         pos = sizeof (struct journal_prefix) + 
  94.                         sizeof (int) * rec->rec_head.ngroups;
  95.         switch (rec->rec_head.opcode)
  96.         {
  97.                 case KML_CREATE:
  98.                         error = unpack_create (&rec->rec_kml.create, 
  99.                                         kml_buf, pos, &rec_offs);
  100.                         break;
  101.                 case KML_MKDIR:
  102.                         error = unpack_mkdir (&rec->rec_kml.mkdir, 
  103.                                         kml_buf, pos, &rec_offs);
  104.                         break;
  105.                 case KML_UNLINK:
  106.                         error = unpack_unlink (&rec->rec_kml.unlink, 
  107.                                         kml_buf, pos, &rec_offs);
  108.                         break;
  109.                 case KML_RMDIR:
  110.                         error = unpack_rmdir (&rec->rec_kml.rmdir, 
  111.                                         kml_buf, pos, &rec_offs);
  112.                         break;
  113.                 case KML_CLOSE:
  114.                         error = unpack_close (&rec->rec_kml.close, 
  115.                                         kml_buf, pos, &rec_offs);
  116.                         break;
  117.                 case KML_SYMLINK:
  118.                         error = unpack_symlink (&rec->rec_kml.symlink, 
  119.                                         kml_buf, pos, &rec_offs);
  120.                         break;
  121.                 case KML_RENAME:
  122.                         error = unpack_rename (&rec->rec_kml.rename, 
  123.                                         kml_buf, pos, &rec_offs);
  124.                         break;
  125.                 case KML_SETATTR:
  126.                         error = unpack_setattr (&rec->rec_kml.setattr, 
  127.                                         kml_buf, pos, &rec_offs);
  128.                         break;
  129.                 case KML_LINK:
  130.                         error = unpack_link (&rec->rec_kml.link, 
  131.                                         kml_buf, pos, &rec_offs);
  132.                         break;
  133.                 case KML_OPEN:
  134.                         error = unpack_open (&rec->rec_kml.open, 
  135.                                         kml_buf, pos, &rec_offs);
  136.                         break;
  137.                 case KML_MKNOD:
  138.                         error = unpack_mknod (&rec->rec_kml.mknod, 
  139.                                         kml_buf, pos, &rec_offs);
  140.                         break;
  141. #if 0
  142.                 case KML_ENDMARK:
  143.                         error = unpack_endmark (&rec->rec_kml.endmark, 
  144.                                         kml_buf, pos, &rec_offs);
  145.                         break;
  146. #endif
  147.                 default:
  148.                         CDEBUG (D_KML, "wrong opcode::%un", 
  149.                                         rec->rec_head.opcode);
  150.                         EXIT;
  151.                         return -EINVAL;
  152.         } 
  153.         if (error) {
  154.                 PRESTO_FREE (rec, sizeof (struct kml_rec));
  155.                 return -EINVAL;
  156.         }
  157.         p = kml_buf + rec_offs;
  158.         p = dlogit (&rec->rec_tail, p, sizeof (struct journal_suffix));
  159.         memset (&rec->kml_optimize, 0, sizeof (struct kml_optimize));
  160.         *newrec = rec;
  161.         EXIT;
  162.         return 0;
  163. }
  165. static int size_round (int val)
  166. {
  167.         return (val + 3) & (~0x3);
  168. }
  170. static int unpack_create (struct kml_create *rec, char *buf, 
  171.                                 int pos, int *rec_offs)
  172. {
  173.         char *p, *q;
  174.         int unpack_size = 88;
  175.         int pathlen;
  177.         ENTRY;
  178.         p = buf + pos;
  179.         p = dlogit (&rec->old_parentv, p, sizeof (struct presto_version));
  180.         p = dlogit (&rec->new_parentv, p, sizeof (struct presto_version));
  181.         p = dlogit (&rec->new_objectv, p, sizeof (struct presto_version));
  182.         p = dlogit (&rec->mode, p, sizeof (int));
  183.         p = dlogit (&rec->uid, p, sizeof (int));
  184.         p = dlogit (&rec->gid, p, sizeof (int));
  185.         p = dlogit (&pathlen, p, sizeof (int));
  187.         PRESTO_ALLOC(q, char *, pathlen + 1);
  188.         if (q == NULL) {
  189.                 EXIT;
  190.                 return -ENOMEM;
  191.         }
  193.         memcpy (q, p, pathlen);
  194.         q[pathlen] = '';
  195.         rec->path = q;
  197.         *rec_offs = pos + unpack_size + size_round(pathlen);
  198.         EXIT;
  199.         return 0;
  200. }
  202. static int unpack_open (struct kml_open *rec, char *buf, 
  203.                                 int pos, int *rec_offs)
  204. {
  205.         *rec_offs = pos;
  206.         return 0;
  207. }
  209. static int unpack_symlink (struct kml_symlink *rec, char *buf, 
  210.                                 int pos, int *rec_offs)
  211. {
  212.         char *p, *q;
  213.         int unpack_size = 88;
  214.         int pathlen, targetlen;
  216.         ENTRY;
  217.         p = buf + pos;
  218.         p = dlogit (&rec->old_parentv, p, sizeof (struct presto_version));
  219.         p = dlogit (&rec->new_parentv, p, sizeof (struct presto_version));
  220.         p = dlogit (&rec->new_objectv, p, sizeof (struct presto_version));
  221.         p = dlogit (&rec->uid, p, sizeof (int));
  222.         p = dlogit (&rec->gid, p, sizeof (int));
  223.         p = dlogit (&pathlen, p, sizeof (int));
  224.         p = dlogit (&targetlen, p, sizeof (int));
  226.         PRESTO_ALLOC(q, char *, pathlen + 1);
  227.         if (q == NULL) {
  228.                 EXIT;
  229.                 return -ENOMEM;
  230.         }
  232.         memcpy (q, p, pathlen);
  233.         q[pathlen] = '';
  234.         rec->sourcepath = q;
  236.         PRESTO_ALLOC(q, char *, targetlen + 1);
  237.         if (q == NULL) {
  238.                 PRESTO_FREE (rec->sourcepath, pathlen + 1);
  239.                 EXIT;
  240.                 return -ENOMEM;
  241.         }
  243.         memcpy (q, p, targetlen);
  244.         q[targetlen] = '';
  245.         rec->targetpath = q;
  247.         *rec_offs = pos + unpack_size + size_round(pathlen) +
  248.                         size_round(targetlen);
  249.         EXIT;
  250.         return 0;
  251. }
  253. static int unpack_mknod (struct kml_mknod *rec, char *buf, 
  254.                                 int pos, int *rec_offs)
  255. {
  256.         char *p, *q;
  257.         int unpack_size = 96;
  258.         int pathlen;
  260.         ENTRY;
  261.         p = buf + pos;
  262.         p = dlogit (&rec->old_parentv, p, sizeof (struct presto_version));
  263.         p = dlogit (&rec->new_parentv, p, sizeof (struct presto_version));
  264.         p = dlogit (&rec->new_objectv, p, sizeof (struct presto_version));
  265.         p = dlogit (&rec->mode, p, sizeof (int));
  266.         p = dlogit (&rec->uid, p, sizeof (int));
  267.         p = dlogit (&rec->gid, p, sizeof (int));
  268.         p = dlogit (&rec->major, p, sizeof (int));
  269.         p = dlogit (&rec->minor, p, sizeof (int));
  270.         p = dlogit (&pathlen, p, sizeof (int));
  272.         PRESTO_ALLOC(q, char *, pathlen + 1);
  273.         if (q == NULL) {
  274.                 EXIT;
  275.                 return -ENOMEM;
  276.         }
  278.         memcpy (q, p, pathlen);
  279.         q[pathlen] = '';
  280.         rec->path = q;
  282.         *rec_offs = pos + unpack_size + size_round(pathlen);
  283.         EXIT;
  284.         return 0;
  285. }
  287. static int unpack_link (struct kml_link *rec, char *buf, 
  288.                                 int pos, int *rec_offs)
  289. {
  290.         char *p, *q;
  291.         int unpack_size = 80;
  292.         int pathlen, targetlen;
  294.         ENTRY;
  295.         p = buf + pos;
  296.         p = dlogit (&rec->old_parentv, p, sizeof (struct presto_version));
  297.         p = dlogit (&rec->new_parentv, p, sizeof (struct presto_version));
  298.         p = dlogit (&rec->new_objectv, p, sizeof (struct presto_version));
  299.         p = dlogit (&pathlen, p, sizeof (int));
  300.         p = dlogit (&targetlen, p, sizeof (int));
  302.         PRESTO_ALLOC(q, char *, pathlen + 1);
  303.         if (q == NULL) {
  304.                 EXIT;
  305.                 return -ENOMEM;
  306.         }
  308.         memcpy (q, p, pathlen);
  309.         q[pathlen] = '';
  310.         rec->sourcepath = q;
  311.         p += size_round (pathlen);
  313.         PRESTO_ALLOC(q, char *, targetlen + 1);
  314.         if (q == NULL) {
  315.                 PRESTO_FREE (rec->sourcepath, pathlen + 1);
  316.                 EXIT;
  317.                 return -ENOMEM;
  318.         }
  319.         memcpy (q, p, targetlen);
  320.         q[targetlen] = '';
  321.         rec->targetpath = q;
  323.         *rec_offs = pos + unpack_size + size_round(pathlen) +
  324.                         size_round(targetlen);
  325.         EXIT;
  326.         return 0;
  327. }
  329. static int unpack_rename (struct kml_rename *rec, char *buf, 
  330.                                 int pos, int *rec_offs)
  331. {
  332.         char *p, *q;
  333.         int unpack_size = 104;
  334.         int pathlen, targetlen;
  336.         ENTRY;
  337.         p = buf + pos;
  338.         p = dlogit (&rec->old_objectv, p, sizeof (struct presto_version));
  339.         p = dlogit (&rec->new_objectv, p, sizeof (struct presto_version));
  340.         p = dlogit (&rec->new_tgtv, p, sizeof (struct presto_version));
  341.         p = dlogit (&rec->old_tgtv, p, sizeof (struct presto_version));
  342.         p = dlogit (&pathlen, p, sizeof (int));
  343.         p = dlogit (&targetlen, p, sizeof (int));
  345.         PRESTO_ALLOC(q, char *, pathlen + 1);
  346.         if (q == NULL) {
  347.                 EXIT;
  348.                 return -ENOMEM;
  349.         }
  351.         memcpy (q, p, pathlen);
  352.         q[pathlen] = '';
  353.         rec->sourcepath = q;
  354.         p += size_round (pathlen);
  356.         PRESTO_ALLOC(q, char *, targetlen + 1);
  357.         if (q == NULL) {
  358.                 PRESTO_FREE (rec->sourcepath, pathlen + 1);
  359.                 EXIT;
  360.                 return -ENOMEM;
  361.         }
  363.         memcpy (q, p, targetlen);
  364.         q[targetlen] = '';
  365.         rec->targetpath = q;
  367.         *rec_offs = pos + unpack_size + size_round(pathlen) +
  368.                         size_round(targetlen);
  369.         EXIT;
  370.         return 0;
  371. }
  373. static int unpack_unlink (struct kml_unlink *rec, char *buf, 
  374.                                 int pos, int *rec_offs)
  375. {
  376.         char *p, *q;
  377.         int unpack_size = 80;
  378.         int pathlen, targetlen;
  380.         ENTRY;
  381.         p = buf + pos;
  382.         p = dlogit (&rec->old_parentv, p, sizeof (struct presto_version));
  383.         p = dlogit (&rec->new_parentv, p, sizeof (struct presto_version));
  384.         p = dlogit (&rec->old_tgtv, p, sizeof (struct presto_version));
  385.         p = dlogit (&pathlen, p, sizeof (int));
  386.         p = dlogit (&targetlen, p, sizeof (int));
  388.         PRESTO_ALLOC(q, char *, pathlen + 1);
  389.         if (q == NULL) {
  390.                 EXIT;
  391.                 return -ENOMEM;
  392.         }
  394.         memcpy (q, p, pathlen);
  395.         q[pathlen] = '';
  396.         rec->path = q;
  397.         p += size_round (pathlen);
  399.         PRESTO_ALLOC(q, char *, targetlen + 1);
  400.         if (q == NULL) {
  401.                 PRESTO_FREE (rec->path, pathlen + 1);
  402.                 EXIT;
  403.                 return -ENOMEM;
  404.         }
  406.         memcpy (q, p, targetlen);
  407.         q[targetlen] = '';
  408.         rec->name = q;
  410.         /* fix the presto_journal_unlink problem */
  411.         *rec_offs = pos + unpack_size + size_round(pathlen) +
  412.                         size_round(targetlen);
  413.         EXIT;
  414.         return 0;
  415. }
  417. static int unpack_rmdir (struct kml_rmdir *rec, char *buf, 
  418.                                 int pos, int *rec_offs)
  419. {
  420.         char *p, *q;
  421.         int unpack_size = 80;
  422.         int pathlen, targetlen;
  424.         ENTRY;
  425.         p = buf + pos;
  426.         p = dlogit (&rec->old_parentv, p, sizeof (struct presto_version));
  427.         p = dlogit (&rec->new_parentv, p, sizeof (struct presto_version));
  428.         p = dlogit (&rec->old_tgtv, p, sizeof (struct presto_version));
  429.         p = dlogit (&pathlen, p, sizeof (int));
  430.         p = dlogit (&targetlen, p, sizeof (int));
  432.         PRESTO_ALLOC(q, char *, pathlen + 1);
  433.         if (q == NULL) {
  434.                 EXIT;
  435.                 return -ENOMEM;
  436.         }
  438.         memcpy (q, p, pathlen);
  439.         q[pathlen] = '';
  440.         rec->path = q;
  441.         p += size_round (pathlen);
  443.         PRESTO_ALLOC(q, char *, targetlen + 1);
  444.         if (q == NULL) {
  445.                 PRESTO_FREE (rec->path, pathlen + 1);
  446.                 EXIT;
  447.                 return -ENOMEM;
  448.         }
  449.         memcpy (q, p, targetlen);
  450.         q[targetlen] = '';
  451.         rec->name = q;
  453.         *rec_offs = pos + unpack_size + size_round(pathlen) +
  454.                         size_round(targetlen);
  455.         EXIT;
  456.         return 0;
  457. }
  459. static int unpack_setattr (struct kml_setattr *rec, char *buf, 
  460.                                 int pos, int *rec_offs)
  461. {
  462.         char *p, *q;
  463.         int unpack_size = 72;
  464.         struct kml_attr {
  465.                 __u64   size, mtime, ctime;
  466.         } objattr;
  467.         int     valid, mode, uid, gid, flags;
  468.         int pathlen;
  470.         ENTRY;
  471.         p = buf + pos;
  472.         p = dlogit (&rec->old_objectv, p, sizeof (struct presto_version));
  473.         p = dlogit (&valid, p, sizeof (int));
  474.         p = dlogit (&mode, p, sizeof (int));
  475.         p = dlogit (&uid, p, sizeof (int));
  476.         p = dlogit (&gid, p, sizeof (int));
  477.         p = dlogit (&objattr, p, sizeof (struct kml_attr));
  478.         p = dlogit (&flags, p, sizeof (int));
  479.         p = dlogit (&pathlen, p, sizeof (int));
  481.         rec->iattr.ia_valid = valid;
  482.         rec->iattr.ia_mode = mode;
  483.         rec->iattr.ia_uid = uid;
  484.         rec->iattr.ia_gid = gid;
  485.         rec->iattr.ia_size = objattr.size;
  486.         rec->iattr.ia_mtime = objattr.mtime;
  487.         rec->iattr.ia_ctime = objattr.ctime;
  488.         rec->iattr.ia_atime = 0;
  489.         rec->iattr.ia_attr_flags = flags;
  491.         PRESTO_ALLOC(q, char *, pathlen + 1);
  492.         if (q == NULL) {
  493.                 EXIT;
  494.                 return -ENOMEM;
  495.         }
  496.         memcpy (q, p, pathlen);
  497.         q[pathlen] = '';
  498.         rec->path = q;
  499.         p += pathlen;
  501.         *rec_offs = pos + unpack_size + size_round(pathlen);
  502.         EXIT;
  503.         return 0;
  504. }
  506. static int unpack_close (struct kml_close *rec, char *buf, 
  507.                                 int pos, int *rec_offs)
  508. {
  509.         char *p, *q;
  510.         int unpack_size = 52;
  511.         int pathlen;
  513.         ENTRY;
  514.         p = buf + pos;
  515.         p = dlogit (&rec->open_mode, p, sizeof (int));
  516.         p = dlogit (&rec->open_uid, p, sizeof (int));
  517.         p = dlogit (&rec->open_gid, p, sizeof (int));
  518.         p = dlogit (&rec->new_objectv, p, sizeof (struct presto_version));
  519.         p = dlogit (&rec->ino, p, sizeof (__u64));
  520.         p = dlogit (&rec->generation, p, sizeof (int));
  521.         p = dlogit (&pathlen, p, sizeof (int));
  523.         PRESTO_ALLOC(q, char *, pathlen + 1);
  524.         if (q == NULL) {
  525.                 EXIT;
  526.                 return -ENOMEM;
  527.         }
  529.         memcpy (q, p, pathlen);
  530.         q[pathlen] = '';
  531.         rec->path = q;
  532.         p += pathlen;
  534.         *rec_offs = pos + unpack_size + size_round(pathlen);
  535.         EXIT;
  536.         return 0;
  537. }
  539. static int unpack_mkdir (struct kml_mkdir *rec, char *buf, 
  540.                                 int pos, int *rec_offs)
  541. {
  542.         char *p, *q;
  543.         int unpack_size = 88;
  544.         int pathlen;
  546.         ENTRY;
  547.         p = buf + pos;
  548.         p = dlogit (&rec->old_parentv, p, sizeof (struct presto_version));
  549.         p = dlogit (&rec->new_parentv, p, sizeof (struct presto_version));
  550.         p = dlogit (&rec->new_objectv, p, sizeof (struct presto_version));
  551.         p = dlogit (&rec->mode, p, sizeof (int));
  552.         p = dlogit (&rec->uid, p, sizeof (int));
  553.         p = dlogit (&rec->gid, p, sizeof (int));
  554.         p = dlogit (&pathlen, p, sizeof (int));
  556.         PRESTO_ALLOC(q, char *, pathlen + 1);
  557.         if (q == NULL) {
  558.                 EXIT;
  559.                 return -ENOMEM;
  560.         }
  562.         memcpy (q, p, pathlen);
  563.         q[pathlen] = '';
  564.         rec->path = q;
  565.         p += pathlen;
  567.         *rec_offs = pos + unpack_size + size_round(pathlen);
  568.         EXIT;
  569.         return 0;
  570. }
  572. #if 0
  573. static int unpack_endmark (struct kml_endmark *rec, char *buf, 
  574.                                 int pos, int *rec_offs)
  575. {
  576.         char *p;
  577.         p = buf + pos;
  578.         p = dlogit (&rec->total, p, sizeof (int));
  580.         PRESTO_ALLOC (rec->kop, struct kml_kop_node *, 
  581.                         sizeof (struct kml_kop_node) * rec->total);
  582.         if (rec->kop == NULL) {
  583.                 EXIT;
  584.                 return -ENOMEM;
  585.         }
  587.         p = dlogit (rec->kop, p, sizeof (struct kml_kop_node) * rec->total);
  589.         *rec_offs = pos + sizeof (int) + sizeof (struct kml_kop_node) * rec->total;
  590.         return 0;
  591. }
  592. #endif
  594. static char *kml_version (struct presto_version *ver)
  595. {
  596.         static char buf[256];
  597.         sprintf (buf, "mt::%lld, ct::%lld, size::%lld",
  598.                 ver->pv_mtime, ver->pv_ctime, ver->pv_size); 
  599.         return buf;
  600. }
  602. static void print_kml_prefix (struct big_journal_prefix *head)
  603. {
  604.         int i;
  606.         CDEBUG (D_KML, " === KML PREFIXn");
  607.         CDEBUG (D_KML, "     len        = %un", head->len);
  608.         CDEBUG (D_KML, "     version    = %un", head->version);
  609.         CDEBUG (D_KML, "     pid        = %un", head->pid);
  610.         CDEBUG (D_KML, "     uid        = %un", head->uid);
  611.         CDEBUG (D_KML, "     fsuid      = %un", head->fsuid);
  612.         CDEBUG (D_KML, "     fsgid      = %un", head->fsgid);
  613.         CDEBUG (D_KML, "     opcode     = %un", head->opcode);
  614.         CDEBUG (D_KML, "     ngroup     = %u",  head->ngroups);
  615.         for (i = 0; i < head->ngroups; i++)
  616.                 CDEBUG (D_KML, "%u  ",  head->groups[i]);
  617.         CDEBUG (D_KML, "n");
  618. }
  620. static void print_kml_create (struct kml_create *rec)
  621. {
  622.         CDEBUG (D_KML, " === CREATEn");
  623.         CDEBUG (D_KML, "     path::%sn", rec->path);
  624.         CDEBUG (D_KML, "     new_objv::%sn", kml_version (&rec->new_objectv));
  625.         CDEBUG (D_KML, "     old_parv::%sn", kml_version (&rec->old_parentv));
  626.         CDEBUG (D_KML, "     new_parv::%sn", kml_version (&rec->new_parentv));
  627.         CDEBUG (D_KML, "     mode::%on", rec->mode);
  628.         CDEBUG (D_KML, "     uid::%dn", rec->uid);
  629.         CDEBUG (D_KML, "     gid::%dn", rec->gid);
  630. }
  632. static void print_kml_mkdir (struct kml_mkdir *rec)
  633. {
  634.         CDEBUG (D_KML, " === MKDIRn");
  635.         CDEBUG (D_KML, "     path::%sn", rec->path);
  636.         CDEBUG (D_KML, "     new_objv::%sn", kml_version (&rec->new_objectv));
  637.         CDEBUG (D_KML, "     old_parv::%sn", kml_version (&rec->old_parentv));
  638.         CDEBUG (D_KML, "     new_parv::%sn", kml_version (&rec->new_parentv));
  639.         CDEBUG (D_KML, "     mode::%on", rec->mode);
  640.         CDEBUG (D_KML, "     uid::%dn", rec->uid);
  641.         CDEBUG (D_KML, "     gid::%dn", rec->gid);
  642. }
  644. static void print_kml_unlink (struct kml_unlink *rec)
  645. {
  646.         CDEBUG (D_KML, " === UNLINKn");
  647.         CDEBUG (D_KML, "     path::%s/%sn", rec->path, rec->name);
  648.         CDEBUG (D_KML, "     old_tgtv::%sn", kml_version (&rec->old_tgtv));
  649.         CDEBUG (D_KML, "     old_parv::%sn", kml_version (&rec->old_parentv));
  650.         CDEBUG (D_KML, "     new_parv::%sn", kml_version (&rec->new_parentv));
  651. }
  653. static void print_kml_rmdir (struct kml_rmdir *rec)
  654. {
  655.         CDEBUG (D_KML, " === RMDIRn");
  656.         CDEBUG (D_KML, "     path::%s/%sn", rec->path, rec->name);
  657.         CDEBUG (D_KML, "     old_tgtv::%sn", kml_version (&rec->old_tgtv));
  658.         CDEBUG (D_KML, "     old_parv::%sn", kml_version (&rec->old_parentv));
  659.         CDEBUG (D_KML, "     new_parv::%sn", kml_version (&rec->new_parentv));
  660. }
  662. static void print_kml_close (struct kml_close *rec)
  663. {
  664.         CDEBUG (D_KML, " === CLOSEn");
  665.         CDEBUG (D_KML, "     mode::%on", rec->open_mode);
  666.         CDEBUG (D_KML, "     uid::%dn", rec->open_uid);
  667.         CDEBUG (D_KML, "     gid::%dn", rec->open_gid);
  668.         CDEBUG (D_KML, "     path::%sn", rec->path);
  669.         CDEBUG (D_KML, "     new_objv::%sn", kml_version (&rec->new_objectv));
  670.         CDEBUG (D_KML, "     ino::%lldn", rec->ino);
  671.         CDEBUG (D_KML, "     gen::%un", rec->generation);
  672. }
  674. static void print_kml_symlink (struct kml_symlink *rec)
  675. {
  676.         CDEBUG (D_KML, " === SYMLINKn");
  677.         CDEBUG (D_KML, "     s-path::%sn", rec->sourcepath);
  678.         CDEBUG (D_KML, "     t-path::%sn", rec->targetpath);
  679.         CDEBUG (D_KML, "     old_parv::%sn", kml_version (&rec->old_parentv));
  680.         CDEBUG (D_KML, "     new_parv::%sn", kml_version (&rec->new_parentv));
  681.         CDEBUG (D_KML, "     new_objv::%sn", kml_version (&rec->new_objectv));
  682.         CDEBUG (D_KML, "     uid::%dn", rec->uid);
  683.         CDEBUG (D_KML, "     gid::%dn", rec->gid);
  684. }
  686. static void print_kml_rename (struct kml_rename *rec)
  687. {
  688.         CDEBUG (D_KML, " === RENAMEn");
  689.         CDEBUG (D_KML, "     s-path::%sn", rec->sourcepath);
  690.         CDEBUG (D_KML, "     t-path::%sn", rec->targetpath);
  691.         CDEBUG (D_KML, "     old_tgtv::%sn", kml_version (&rec->old_tgtv));
  692.         CDEBUG (D_KML, "     new_tgtv::%sn", kml_version (&rec->new_tgtv));
  693.         CDEBUG (D_KML, "     new_objv::%sn", kml_version (&rec->new_objectv));
  694.         CDEBUG (D_KML, "     old_objv::%sn", kml_version (&rec->old_objectv));
  695. }
  697. static void print_kml_setattr (struct kml_setattr *rec)
  698. {
  699.         CDEBUG (D_KML, " === SETATTRn");
  700.         CDEBUG (D_KML, "     path::%sn", rec->path);
  701.         CDEBUG (D_KML, "     old_objv::%sn", kml_version (&rec->old_objectv));
  702.         CDEBUG (D_KML, "     valid::0x%xn", rec->iattr.ia_valid);
  703.         CDEBUG (D_KML, "     mode::%on", rec->iattr.ia_mode);
  704.         CDEBUG (D_KML, "     uid::%dn", rec->iattr.ia_uid);
  705.         CDEBUG (D_KML, "     gid::%dn", rec->iattr.ia_gid);
  706.         CDEBUG (D_KML, "     size::%un", (u32) rec->iattr.ia_size);
  707.         CDEBUG (D_KML, "     mtime::%un", (u32) rec->iattr.ia_mtime);
  708.         CDEBUG (D_KML, "     ctime::%un", (u32) rec->iattr.ia_ctime);
  709.         CDEBUG (D_KML, "     flags::%un", (u32) rec->iattr.ia_attr_flags);
  710. }
  712. static void print_kml_link (struct kml_link *rec)
  713. {
  714.         CDEBUG (D_KML, " === LINKn");
  715.         CDEBUG (D_KML, "     path::%s ==> %sn", rec->sourcepath, rec->targetpath);
  716.         CDEBUG (D_KML, "     old_parv::%sn", kml_version (&rec->old_parentv));
  717.         CDEBUG (D_KML, "     new_obj::%sn", kml_version (&rec->new_objectv));
  718.         CDEBUG (D_KML, "     new_parv::%sn", kml_version (&rec->new_parentv));
  719. }
  721. static void print_kml_mknod (struct kml_mknod *rec)
  722. {
  723.         CDEBUG (D_KML, " === MKNODn");
  724.         CDEBUG (D_KML, "     path::%sn", rec->path);
  725.         CDEBUG (D_KML, "     new_obj::%sn", kml_version (&rec->new_objectv));
  726.         CDEBUG (D_KML, "     old_parv::%sn", kml_version (&rec->old_parentv));
  727.         CDEBUG (D_KML, "     new_parv::%sn", kml_version (&rec->new_parentv));
  728.         CDEBUG (D_KML, "     mode::%on", rec->mode);
  729.         CDEBUG (D_KML, "     uid::%dn", rec->uid);
  730.         CDEBUG (D_KML, "     gid::%dn", rec->gid);
  731.         CDEBUG (D_KML, "     major::%dn", rec->major);
  732.         CDEBUG (D_KML, "     minor::%dn", rec->minor);
  733. }
  735. static void print_kml_open (struct kml_open *rec)
  736. {
  737.         CDEBUG (D_KML, " === OPENn");
  738. }
  740. #if 0
  741. static void print_kml_endmark (struct kml_endmark *rec)
  742. {
  743.         int i;
  744.         CDEBUG (D_KML, " === ENDMARKn");
  745.         CDEBUG (D_KML, "     total::%un", rec->total);
  746.         for (i = 0; i < rec->total; i++)
  747.         {       
  748.                 CDEBUG (D_KML, "         recno=%ld::flag=%ld,op=%ld, i_ino=%ld, 
  749.                         i_nlink=%ldn", (long) rec->kop[i].kml_recno, 
  750.                         (long) rec->kop[i].kml_flag, (long) rec->kop[i].kml_op, 
  751.                         (long) rec->kop[i].i_ino, (long) rec->kop[i].i_nlink);
  752.         }
  753. }
  754. #endif
  756. static void print_kml_optimize (struct kml_optimize  *rec)
  757. {
  758.         CDEBUG (D_KML, " === OPTIMIZEn");
  759.         if (rec->kml_flag == KML_REC_DELETE)
  760.                 CDEBUG (D_KML, "     kml_flag::deletedn");
  761.         else
  762.                 CDEBUG (D_KML, "     kml_flag::existn");
  763.         CDEBUG (D_KML, "     kml_op::%un", rec->kml_op);
  764.         CDEBUG (D_KML, "     i_nlink::%dn", rec->i_nlink);
  765.         CDEBUG (D_KML, "     i_ino::%un", rec->i_ino);
  766. }
  768. static void print_kml_suffix (struct journal_suffix *tail)
  769. {
  770.         CDEBUG (D_KML, " === KML SUFFIXn");
  771.         CDEBUG (D_KML, "     prevrec::%ldn", tail->prevrec);
  772.         CDEBUG (D_KML, "     recno::%ldn", (long) tail->recno);
  773.         CDEBUG (D_KML, "     time::%dn", tail->time);
  774.         CDEBUG (D_KML, "     len::%dn", tail->len);
  775. }
  777. void kml_printrec (struct kml_rec *rec, int kml_printop)
  778. {
  779.         if (kml_printop & PRINT_KML_PREFIX)
  780.                 print_kml_prefix (&rec->rec_head);
  781.         if (kml_printop & PRINT_KML_REC) 
  782.         { 
  783.                 switch (rec->rec_head.opcode)
  784.                 {
  785.                         case KML_CREATE:
  786.                                 print_kml_create (&rec->rec_kml.create);
  787.                                 break;
  788.                         case KML_MKDIR:
  789.                                 print_kml_mkdir (&rec->rec_kml.mkdir);
  790.                                 break;
  791.                         case KML_UNLINK:
  792.                                 print_kml_unlink (&rec->rec_kml.unlink);
  793.                                 break;
  794.                         case KML_RMDIR:
  795.                                 print_kml_rmdir (&rec->rec_kml.rmdir);
  796.                                 break;
  797.                         case KML_CLOSE:
  798.                                 print_kml_close (&rec->rec_kml.close);
  799.                                 break;
  800.                         case KML_SYMLINK:
  801.                                 print_kml_symlink (&rec->rec_kml.symlink);
  802.                                 break;
  803.                         case KML_RENAME:
  804.                                 print_kml_rename (&rec->rec_kml.rename);
  805.                                 break;
  806.                         case KML_SETATTR:
  807.                                 print_kml_setattr (&rec->rec_kml.setattr);
  808.                                 break;
  809.                         case KML_LINK:
  810.                                 print_kml_link (&rec->rec_kml.link);
  811.                                 break;
  812.                         case KML_OPEN:
  813.                                 print_kml_open (&rec->rec_kml.open);
  814.                                 break;
  815.                         case KML_MKNOD:
  816.                                 print_kml_mknod (&rec->rec_kml.mknod);
  817.                                 break;
  818. #if 0
  819.                         case KML_ENDMARK:
  820.                                 print_kml_endmark (&rec->rec_kml.endmark);
  821. #endif
  822.                                 break;
  823.                         default:
  824.                                 CDEBUG (D_KML, " === BAD RECORD, opcode=%un",
  825.                                         rec->rec_head.opcode);
  826.                                 break;
  827.                 }
  828.         }
  829.         if (kml_printop & PRINT_KML_SUFFIX)
  830.                 print_kml_suffix (&rec->rec_tail);
  831.         if (kml_printop & PRINT_KML_OPTIMIZE)
  832.                 print_kml_optimize (&rec->kml_optimize);
  833. }
  835. void kml_freerec (struct kml_rec *rec)
  836. {
  837.         char *sourcepath = NULL,
  838.              *targetpath = NULL;
  839.         switch (rec->rec_head.opcode)
  840.         {
  841.                 case KML_CREATE:
  842.                         sourcepath = rec->rec_kml.create.path;
  843.                         break;
  844.                 case KML_MKDIR:
  845.                         sourcepath = rec->rec_kml.create.path;
  846.                         break;
  847.                 case KML_UNLINK:
  848.                         sourcepath = rec->rec_kml.unlink.path;
  849.                         targetpath = rec->rec_kml.unlink.name;
  850.                         break;
  851.                 case KML_RMDIR:
  852.                         sourcepath = rec->rec_kml.rmdir.path;
  853.                         targetpath = rec->rec_kml.rmdir.name;
  854.                         break;
  855.                 case KML_CLOSE:
  856.                         sourcepath = rec->rec_kml.close.path;
  857.                         break;
  858.                 case KML_SYMLINK:
  859.                         sourcepath = rec->rec_kml.symlink.sourcepath;
  860.                         targetpath = rec->rec_kml.symlink.targetpath;
  861.                         break;
  862.                 case KML_RENAME:
  863.                         sourcepath = rec->rec_kml.rename.sourcepath;
  864.                         targetpath = rec->rec_kml.rename.targetpath;
  865.                         break;
  866.                 case KML_SETATTR:
  867.                         sourcepath = rec->rec_kml.setattr.path;
  868.                         break;
  869.                 case KML_LINK:
  870.                         sourcepath = rec->rec_kml.link.sourcepath;
  871.                         targetpath = rec->rec_kml.link.targetpath;
  872.                         break;
  873.                 case KML_OPEN:
  874.                         break;
  875.                 case KML_MKNOD:
  876.                         sourcepath = rec->rec_kml.mknod.path;
  877.                         break;
  878. #if 0
  879.                 case KML_ENDMARK:
  880.                         PRESTO_FREE (rec->rec_kml.endmark.kop, sizeof (int) + 
  881.                                 sizeof (struct kml_kop_node) * 
  882.                                 rec->rec_kml.endmark.total);
  883. #endif
  884.                         break;
  885.                 default:
  886.                         break;
  887.         }
  888.         if (sourcepath != NULL)
  889.                 PRESTO_FREE (sourcepath, strlen (sourcepath) + 1);
  890.         if (targetpath != NULL)
  891.                 PRESTO_FREE (targetpath, strlen (targetpath) + 1);
  892. }
  894. char *readrec (char *recbuf, int reclen, int pos, int *size)
  895. {
  896.         char *p = recbuf + pos;
  897.         *size = *((int *) p);
  898.         if (*size > (reclen - pos))
  899.             return NULL;
  900.         return p; 
  901. }
  903. int kml_decoderec (char *buf, int pos, int buflen, int *size, 
  904.                         struct kml_rec **newrec)
  905. {
  906.         char *tmp;
  907.         int  error;
  908.         tmp = readrec (buf, buflen, pos, size);
  909.         if (tmp == NULL)
  910.                 return -EBADF;
  911.         error = kml_unpack (tmp, *size, pos, newrec); 
  912.         return error;
  913. }
  915. #if 0
  916. static void fill_kmlrec_optimize (struct list_head *head, 
  917.                 struct kml_rec *optrec)
  918. {
  919.         struct kml_rec *kmlrec;
  920.         struct list_head *tmp;
  921.         struct kml_endmark *km;
  922.         struct kml_optimize *ko;
  923.         int    n;
  925.         if (optrec->rec_kml.endmark.total == 0)
  926.                 return;
  927.         n = optrec->rec_kml.endmark.total - 1;
  928.         tmp = head->prev;
  929.         km = &optrec->rec_kml.endmark;
  930.         while ( n >= 0 && tmp != head ) 
  931.         {
  932.                 kmlrec = list_entry(tmp, struct kml_rec,
  933.                         kml_optimize.kml_chains);
  934.                 tmp = tmp->prev;
  935.                 if (kmlrec->rec_tail.recno == km->kop[n].kml_recno) 
  936.                 {
  937.                         ko = &kmlrec->kml_optimize;
  938.                         ko->kml_flag = km->kop[n].kml_flag;
  939.                         ko->kml_op   = km->kop[n].kml_op;
  940.                         ko->i_nlink  = km->kop[n].i_nlink;
  941.                         ko->i_ino    = km->kop[n].i_ino;
  942.                         n --;
  943.                 }
  944.         }
  945.         if (n != -1)
  946.                 CDEBUG (D_KML, "Yeah!!!, KML optimize error, recno=%d, n=%dn",
  947.                         optrec->rec_tail.recno, n);     
  948. }
  949. #endif
  951. int decode_kmlrec (struct list_head *head, char *kml_buf, int buflen)
  952. {
  953.         struct kml_rec *rec;
  954.         int    pos = 0, size;
  955.         int    err;
  956.         while (pos < buflen) {
  957.                 err = kml_decoderec (kml_buf, pos, buflen, &size, &rec);
  958.                 if (err != 0)
  959.                         break;
  960. #if 0
  961.                 if (rec->rec_head.opcode == KML_ENDMARK) {
  962.                         fill_kmlrec_optimize (head, rec);
  963.                         mark_rec_deleted (rec);
  964.                 }
  965. #endif
  966.                 list_add_tail (&rec->kml_optimize.kml_chains, head);
  967.                 pos += size;
  968.         }
  969.         return err;
  970. }
  972. int delete_kmlrec (struct list_head *head)
  973. {
  974.         struct kml_rec *rec;
  975.         struct list_head *tmp;
  977.         if (list_empty(head))
  978.                 return 0;
  979.         tmp = head->next;
  980.         while ( tmp != head ) {
  981.                 rec = list_entry(tmp, struct kml_rec, 
  982.                         kml_optimize.kml_chains);
  983.                 tmp = tmp->next;
  984.                 kml_freerec (rec);
  985.         }
  986.         INIT_LIST_HEAD(head);
  987.         return 0;
  988. }
  990. int print_allkmlrec (struct list_head *head, int printop)
  991. {
  992.         struct kml_rec *rec;
  993.         struct list_head *tmp;
  995.         if (list_empty(head))
  996.                 return 0;
  997.         tmp = head->next;
  998.         while ( tmp != head ) {
  999.                 rec = list_entry(tmp, struct kml_rec,
  1000.                         kml_optimize.kml_chains);
  1001.                 tmp = tmp->next;
  1002. #if 0
  1003.                 if (printop & PRINT_KML_EXIST) {
  1004.                         if (is_deleted_node (rec))
  1005.                                 continue;
  1006.                 }
  1007.                 else if (printop & PRINT_KML_DELETE) {
  1008.                         if (! is_deleted_node (rec))
  1009.                                 continue;
  1010.                 }
  1011. #endif
  1012.                 kml_printrec (rec, printop);
  1013.         }
  1014.         INIT_LIST_HEAD(head);
  1015.         return 0;
  1016. }