X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=java%2Fcom_redhat_et_libguestfs_GuestFS.c;h=501e8d12bb07e3a5addb9c86505c3d5439e54fb5;hp=f012a4b88adc7ba1694054f5ff7cbc7f9bbb0405;hb=826020fe18bf2eee43f8afea392874bb88c0650a;hpb=ab0397017cc26833c09946cca19d86b907822a94

diff --git a/java/com_redhat_et_libguestfs_GuestFS.c b/java/com_redhat_et_libguestfs_GuestFS.c
index f012a4b..501e8d1 100644
--- a/java/com_redhat_et_libguestfs_GuestFS.c
+++ b/java/com_redhat_et_libguestfs_GuestFS.c
@@ -62,126 +62,161 @@ Java_com_redhat_et_libguestfs_GuestFS__1close
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1launch
-  (JNIEnv *env, jobject obj, jlong jg)
+Java_com_redhat_et_libguestfs_GuestFS__1test0
+  (JNIEnv *env, jobject obj, jlong jg, jstring jstr, jstring joptstr, jobjectArray jstrlist, jboolean jb, jint jinteger, jstring jfilein, jstring jfileout)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
+  const char *str;
+  const char *optstr;
+  int strlist_len;
+  const char **strlist;
+  int b;
+  int integer;
+  const char *filein;
+  const char *fileout;
+  int i;
 
-  r = guestfs_launch (g);
+  str = (*env)->GetStringUTFChars (env, jstr, NULL);
+  optstr = joptstr ? (*env)->GetStringUTFChars (env, joptstr, NULL) : NULL;
+  strlist_len = (*env)->GetArrayLength (env, jstrlist);
+  strlist = guestfs_safe_malloc (g, sizeof (char *) * (strlist_len+1));
+  for (i = 0; i < strlist_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jstrlist, i);
+    strlist[i] = (*env)->GetStringUTFChars (env, o, NULL);
+  }
+  strlist[strlist_len] = NULL;
+  b = jb;
+  integer = jinteger;
+  filein = (*env)->GetStringUTFChars (env, jfilein, NULL);
+  fileout = (*env)->GetStringUTFChars (env, jfileout, NULL);
+  r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
+  (*env)->ReleaseStringUTFChars (env, jstr, str);
+  if (joptstr)
+    (*env)->ReleaseStringUTFChars (env, joptstr, optstr);
+  for (i = 0; i < strlist_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jstrlist, i);
+    (*env)->ReleaseStringUTFChars (env, o, strlist[i]);
+  }
+  free (strlist);
+  (*env)->ReleaseStringUTFChars (env, jfilein, filein);
+  (*env)->ReleaseStringUTFChars (env, jfileout, fileout);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
   }
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1wait_1ready
-  (JNIEnv *env, jobject obj, jlong jg)
+JNIEXPORT jint JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rint
+  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
+  const char *val;
 
-  r = guestfs_wait_ready (g);
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_test0rint (g, val);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return 0;
   }
+  return (jint) r;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1kill_1subprocess
+JNIEXPORT jint JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rinterr
   (JNIEnv *env, jobject obj, jlong jg)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
 
-  r = guestfs_kill_subprocess (g);
+  r = guestfs_test0rinterr (g);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return 0;
   }
+  return (jint) r;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1add_1drive
-  (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
+JNIEXPORT jlong JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rint64
+  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  const char *filename;
+  int64_t r;
+  const char *val;
 
-  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
-  r = guestfs_add_drive (g, filename);
-  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_test0rint64 (g, val);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return 0;
   }
+  return (jlong) r;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1add_1cdrom
-  (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
+JNIEXPORT jlong JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rint64err
+  (JNIEnv *env, jobject obj, jlong jg)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  const char *filename;
+  int64_t r;
 
-  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
-  r = guestfs_add_cdrom (g, filename);
-  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
+  r = guestfs_test0rint64err (g);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return 0;
   }
+  return (jlong) r;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1config
-  (JNIEnv *env, jobject obj, jlong jg, jstring jqemuparam, jstring jqemuvalue)
+JNIEXPORT jboolean JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rbool
+  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *qemuparam;
-  const char *qemuvalue;
+  const char *val;
 
-  qemuparam = (*env)->GetStringUTFChars (env, jqemuparam, NULL);
-  qemuvalue = (*env)->GetStringUTFChars (env, jqemuvalue, NULL);
-  r = guestfs_config (g, qemuparam, qemuvalue);
-  (*env)->ReleaseStringUTFChars (env, jqemuparam, qemuparam);
-  (*env)->ReleaseStringUTFChars (env, jqemuvalue, qemuvalue);
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_test0rbool (g, val);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return 0;
   }
+  return (jboolean) r;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1set_1qemu
-  (JNIEnv *env, jobject obj, jlong jg, jstring jqemu)
+JNIEXPORT jboolean JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rboolerr
+  (JNIEnv *env, jobject obj, jlong jg)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *qemu;
 
-  qemu = (*env)->GetStringUTFChars (env, jqemu, NULL);
-  r = guestfs_set_qemu (g, qemu);
-  (*env)->ReleaseStringUTFChars (env, jqemu, qemu);
+  r = guestfs_test0rboolerr (g);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return 0;
   }
+  return (jboolean) r;
 }
 
 JNIEXPORT jstring JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1get_1qemu
-  (JNIEnv *env, jobject obj, jlong jg)
+Java_com_redhat_et_libguestfs_GuestFS__1test0rconststring
+  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   const char *r;
+  const char *val;
 
-  r = guestfs_get_qemu (g);
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_test0rconststring (g, val);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
@@ -189,31 +224,14 @@ Java_com_redhat_et_libguestfs_GuestFS__1get_1qemu
   return (*env)->NewStringUTF (env, r);
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1set_1path
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
-{
-  guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  const char *path;
-
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_set_path (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
-  if (r == -1) {
-    throw_exception (env, guestfs_last_error (g));
-    return ;
-  }
-}
-
 JNIEXPORT jstring JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1get_1path
+Java_com_redhat_et_libguestfs_GuestFS__1test0rconststringerr
   (JNIEnv *env, jobject obj, jlong jg)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   const char *r;
 
-  r = guestfs_get_path (g);
+  r = guestfs_test0rconststringerr (g);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
@@ -221,121 +239,2109 @@ Java_com_redhat_et_libguestfs_GuestFS__1get_1path
   return (*env)->NewStringUTF (env, r);
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1set_1autosync
-  (JNIEnv *env, jobject obj, jlong jg, jboolean jautosync)
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rstring
+  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  int autosync;
+  jstring jr;
+  char *r;
+  const char *val;
 
-  autosync = jautosync;
-  r = guestfs_set_autosync (g, autosync);
-  if (r == -1) {
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_test0rstring (g, val);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return NULL;
   }
+  jr = (*env)->NewStringUTF (env, r);
+  free (r);
+  return jr;
 }
 
-JNIEXPORT jboolean JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1get_1autosync
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rstringerr
   (JNIEnv *env, jobject obj, jlong jg)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
+  jstring jr;
+  char *r;
 
-  r = guestfs_get_autosync (g);
-  if (r == -1) {
+  r = guestfs_test0rstringerr (g);
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return 0;
+    return NULL;
   }
-  return (jboolean) r;
+  jr = (*env)->NewStringUTF (env, r);
+  free (r);
+  return jr;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1set_1verbose
-  (JNIEnv *env, jobject obj, jlong jg, jboolean jverbose)
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rstringlist
+  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  int verbose;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  const char *val;
+  int i;
 
-  verbose = jverbose;
-  r = guestfs_set_verbose (g, verbose);
-  if (r == -1) {
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_test0rstringlist (g, val);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return NULL;
   }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
+  free (r);
+  return jr;
 }
 
-JNIEXPORT jboolean JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1get_1verbose
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rstringlisterr
   (JNIEnv *env, jobject obj, jlong jg)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  int i;
 
-  r = guestfs_get_verbose (g);
-  if (r == -1) {
+  r = guestfs_test0rstringlisterr (g);
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return 0;
+    return NULL;
   }
-  return (jboolean) r;
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
+  free (r);
+  return jr;
 }
 
-JNIEXPORT jboolean JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1is_1ready
-  (JNIEnv *env, jobject obj, jlong jg)
+JNIEXPORT jobject JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rintbool
+  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
+  jobject jr;
+  jclass cl;
+  jfieldID fl;
+  struct guestfs_int_bool *r;
+  const char *val;
 
-  r = guestfs_is_ready (g);
-  if (r == -1) {
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_test0rintbool (g, val);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return 0;
+    return NULL;
   }
-  return (jboolean) r;
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
+  jr = (*env)->AllocObject (env, cl);
+  fl = (*env)->GetFieldID (env, cl, "i", "I");
+  (*env)->SetIntField (env, jr, fl, r->i);
+  fl = (*env)->GetFieldID (env, cl, "i", "Z");
+  (*env)->SetBooleanField (env, jr, fl, r->b);
+  guestfs_free_int_bool (r);
+  return jr;
 }
 
-JNIEXPORT jboolean JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1is_1config
+JNIEXPORT jobject JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rintboolerr
   (JNIEnv *env, jobject obj, jlong jg)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
+  jobject jr;
+  jclass cl;
+  jfieldID fl;
+  struct guestfs_int_bool *r;
 
-  r = guestfs_is_config (g);
-  if (r == -1) {
+  r = guestfs_test0rintboolerr (g);
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return 0;
+    return NULL;
   }
-  return (jboolean) r;
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
+  jr = (*env)->AllocObject (env, cl);
+  fl = (*env)->GetFieldID (env, cl, "i", "I");
+  (*env)->SetIntField (env, jr, fl, r->i);
+  fl = (*env)->GetFieldID (env, cl, "i", "Z");
+  (*env)->SetBooleanField (env, jr, fl, r->b);
+  guestfs_free_int_bool (r);
+  return jr;
 }
 
-JNIEXPORT jboolean JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1is_1launching
-  (JNIEnv *env, jobject obj, jlong jg)
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rpvlist
+  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-
-  r = guestfs_is_launching (g);
-  if (r == -1) {
-    throw_exception (env, guestfs_last_error (g));
-    return 0;
+  jobjectArray jr;
+  jclass cl;
+  jfieldID fl;
+  jobject jfl;
+  struct guestfs_lvm_pv_list *r;
+  const char *val;
+  int i;
+
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_test0rpvlist (g, val);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
+  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
+  for (i = 0; i < r->len; ++i) {
+    jfl = (*env)->AllocObject (env, cl);
+    fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
+    {
+      char s[33];
+      memcpy (s, r->val[i].pv_uuid, 32);
+      s[32] = 0;
+      fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
+      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
+    }
+    fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
+    fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
+    fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
+    fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
+    fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
+    fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
+    fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
+    fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
+    fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
+    fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
+    fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
+    fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
+    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
+  }
+  guestfs_free_lvm_pv_list (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rpvlisterr
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  jclass cl;
+  jfieldID fl;
+  jobject jfl;
+  struct guestfs_lvm_pv_list *r;
+  int i;
+
+  r = guestfs_test0rpvlisterr (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
+  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
+  for (i = 0; i < r->len; ++i) {
+    jfl = (*env)->AllocObject (env, cl);
+    fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
+    {
+      char s[33];
+      memcpy (s, r->val[i].pv_uuid, 32);
+      s[32] = 0;
+      fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
+      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
+    }
+    fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
+    fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
+    fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
+    fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
+    fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
+    fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
+    fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
+    fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
+    fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
+    fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
+    fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
+    fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
+    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
+  }
+  guestfs_free_lvm_pv_list (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rvglist
+  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  jclass cl;
+  jfieldID fl;
+  jobject jfl;
+  struct guestfs_lvm_vg_list *r;
+  const char *val;
+  int i;
+
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_test0rvglist (g, val);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
+  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
+  for (i = 0; i < r->len; ++i) {
+    jfl = (*env)->AllocObject (env, cl);
+    fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
+    {
+      char s[33];
+      memcpy (s, r->val[i].vg_uuid, 32);
+      s[32] = 0;
+      fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
+      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
+    }
+    fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
+    fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
+    fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
+    fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
+    fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
+    fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
+    fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
+    fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
+    fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
+    fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
+    fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
+    fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
+    fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
+    fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
+    fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
+    fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
+    fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
+    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
+  }
+  guestfs_free_lvm_vg_list (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rvglisterr
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  jclass cl;
+  jfieldID fl;
+  jobject jfl;
+  struct guestfs_lvm_vg_list *r;
+  int i;
+
+  r = guestfs_test0rvglisterr (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
+  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
+  for (i = 0; i < r->len; ++i) {
+    jfl = (*env)->AllocObject (env, cl);
+    fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
+    {
+      char s[33];
+      memcpy (s, r->val[i].vg_uuid, 32);
+      s[32] = 0;
+      fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
+      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
+    }
+    fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
+    fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
+    fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
+    fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
+    fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
+    fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
+    fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
+    fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
+    fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
+    fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
+    fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
+    fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
+    fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
+    fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
+    fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
+    fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
+    fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
+    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
+  }
+  guestfs_free_lvm_vg_list (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rlvlist
+  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  jclass cl;
+  jfieldID fl;
+  jobject jfl;
+  struct guestfs_lvm_lv_list *r;
+  const char *val;
+  int i;
+
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_test0rlvlist (g, val);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
+  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
+  for (i = 0; i < r->len; ++i) {
+    jfl = (*env)->AllocObject (env, cl);
+    fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
+    {
+      char s[33];
+      memcpy (s, r->val[i].lv_uuid, 32);
+      s[32] = 0;
+      fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
+      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
+    }
+    fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
+    fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
+    fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
+    fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
+    fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
+    fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
+    fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
+    fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
+    fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
+    (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
+    fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
+    (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
+    fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
+    fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
+    fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
+    fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
+    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
+  }
+  guestfs_free_lvm_lv_list (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rlvlisterr
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  jclass cl;
+  jfieldID fl;
+  jobject jfl;
+  struct guestfs_lvm_lv_list *r;
+  int i;
+
+  r = guestfs_test0rlvlisterr (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
+  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
+  for (i = 0; i < r->len; ++i) {
+    jfl = (*env)->AllocObject (env, cl);
+    fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
+    {
+      char s[33];
+      memcpy (s, r->val[i].lv_uuid, 32);
+      s[32] = 0;
+      fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
+      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
+    }
+    fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
+    fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
+    fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
+    fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
+    fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
+    fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
+    fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
+    fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
+    fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
+    (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
+    fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
+    (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
+    fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
+    fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
+    fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
+    fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
+    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
+  }
+  guestfs_free_lvm_lv_list (r);
+  return jr;
+}
+
+JNIEXPORT jobject JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rstat
+  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobject jr;
+  jclass cl;
+  jfieldID fl;
+  struct guestfs_stat *r;
+  const char *val;
+
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_test0rstat (g, val);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
+  jr = (*env)->AllocObject (env, cl);
+  fl = (*env)->GetFieldID (env, cl, "dev", "J");
+  (*env)->SetLongField (env, jr, fl, r->dev);
+  fl = (*env)->GetFieldID (env, cl, "ino", "J");
+  (*env)->SetLongField (env, jr, fl, r->ino);
+  fl = (*env)->GetFieldID (env, cl, "mode", "J");
+  (*env)->SetLongField (env, jr, fl, r->mode);
+  fl = (*env)->GetFieldID (env, cl, "nlink", "J");
+  (*env)->SetLongField (env, jr, fl, r->nlink);
+  fl = (*env)->GetFieldID (env, cl, "uid", "J");
+  (*env)->SetLongField (env, jr, fl, r->uid);
+  fl = (*env)->GetFieldID (env, cl, "gid", "J");
+  (*env)->SetLongField (env, jr, fl, r->gid);
+  fl = (*env)->GetFieldID (env, cl, "rdev", "J");
+  (*env)->SetLongField (env, jr, fl, r->rdev);
+  fl = (*env)->GetFieldID (env, cl, "size", "J");
+  (*env)->SetLongField (env, jr, fl, r->size);
+  fl = (*env)->GetFieldID (env, cl, "blksize", "J");
+  (*env)->SetLongField (env, jr, fl, r->blksize);
+  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
+  (*env)->SetLongField (env, jr, fl, r->blocks);
+  fl = (*env)->GetFieldID (env, cl, "atime", "J");
+  (*env)->SetLongField (env, jr, fl, r->atime);
+  fl = (*env)->GetFieldID (env, cl, "mtime", "J");
+  (*env)->SetLongField (env, jr, fl, r->mtime);
+  fl = (*env)->GetFieldID (env, cl, "ctime", "J");
+  (*env)->SetLongField (env, jr, fl, r->ctime);
+  free (r);
+  return jr;
+}
+
+JNIEXPORT jobject JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rstaterr
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobject jr;
+  jclass cl;
+  jfieldID fl;
+  struct guestfs_stat *r;
+
+  r = guestfs_test0rstaterr (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
+  jr = (*env)->AllocObject (env, cl);
+  fl = (*env)->GetFieldID (env, cl, "dev", "J");
+  (*env)->SetLongField (env, jr, fl, r->dev);
+  fl = (*env)->GetFieldID (env, cl, "ino", "J");
+  (*env)->SetLongField (env, jr, fl, r->ino);
+  fl = (*env)->GetFieldID (env, cl, "mode", "J");
+  (*env)->SetLongField (env, jr, fl, r->mode);
+  fl = (*env)->GetFieldID (env, cl, "nlink", "J");
+  (*env)->SetLongField (env, jr, fl, r->nlink);
+  fl = (*env)->GetFieldID (env, cl, "uid", "J");
+  (*env)->SetLongField (env, jr, fl, r->uid);
+  fl = (*env)->GetFieldID (env, cl, "gid", "J");
+  (*env)->SetLongField (env, jr, fl, r->gid);
+  fl = (*env)->GetFieldID (env, cl, "rdev", "J");
+  (*env)->SetLongField (env, jr, fl, r->rdev);
+  fl = (*env)->GetFieldID (env, cl, "size", "J");
+  (*env)->SetLongField (env, jr, fl, r->size);
+  fl = (*env)->GetFieldID (env, cl, "blksize", "J");
+  (*env)->SetLongField (env, jr, fl, r->blksize);
+  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
+  (*env)->SetLongField (env, jr, fl, r->blocks);
+  fl = (*env)->GetFieldID (env, cl, "atime", "J");
+  (*env)->SetLongField (env, jr, fl, r->atime);
+  fl = (*env)->GetFieldID (env, cl, "mtime", "J");
+  (*env)->SetLongField (env, jr, fl, r->mtime);
+  fl = (*env)->GetFieldID (env, cl, "ctime", "J");
+  (*env)->SetLongField (env, jr, fl, r->ctime);
+  free (r);
+  return jr;
+}
+
+JNIEXPORT jobject JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rstatvfs
+  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobject jr;
+  jclass cl;
+  jfieldID fl;
+  struct guestfs_statvfs *r;
+  const char *val;
+
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_test0rstatvfs (g, val);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
+  jr = (*env)->AllocObject (env, cl);
+  fl = (*env)->GetFieldID (env, cl, "bsize", "J");
+  (*env)->SetLongField (env, jr, fl, r->bsize);
+  fl = (*env)->GetFieldID (env, cl, "frsize", "J");
+  (*env)->SetLongField (env, jr, fl, r->frsize);
+  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
+  (*env)->SetLongField (env, jr, fl, r->blocks);
+  fl = (*env)->GetFieldID (env, cl, "bfree", "J");
+  (*env)->SetLongField (env, jr, fl, r->bfree);
+  fl = (*env)->GetFieldID (env, cl, "bavail", "J");
+  (*env)->SetLongField (env, jr, fl, r->bavail);
+  fl = (*env)->GetFieldID (env, cl, "files", "J");
+  (*env)->SetLongField (env, jr, fl, r->files);
+  fl = (*env)->GetFieldID (env, cl, "ffree", "J");
+  (*env)->SetLongField (env, jr, fl, r->ffree);
+  fl = (*env)->GetFieldID (env, cl, "favail", "J");
+  (*env)->SetLongField (env, jr, fl, r->favail);
+  fl = (*env)->GetFieldID (env, cl, "fsid", "J");
+  (*env)->SetLongField (env, jr, fl, r->fsid);
+  fl = (*env)->GetFieldID (env, cl, "flag", "J");
+  (*env)->SetLongField (env, jr, fl, r->flag);
+  fl = (*env)->GetFieldID (env, cl, "namemax", "J");
+  (*env)->SetLongField (env, jr, fl, r->namemax);
+  free (r);
+  return jr;
+}
+
+JNIEXPORT jobject JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rstatvfserr
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobject jr;
+  jclass cl;
+  jfieldID fl;
+  struct guestfs_statvfs *r;
+
+  r = guestfs_test0rstatvfserr (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
+  jr = (*env)->AllocObject (env, cl);
+  fl = (*env)->GetFieldID (env, cl, "bsize", "J");
+  (*env)->SetLongField (env, jr, fl, r->bsize);
+  fl = (*env)->GetFieldID (env, cl, "frsize", "J");
+  (*env)->SetLongField (env, jr, fl, r->frsize);
+  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
+  (*env)->SetLongField (env, jr, fl, r->blocks);
+  fl = (*env)->GetFieldID (env, cl, "bfree", "J");
+  (*env)->SetLongField (env, jr, fl, r->bfree);
+  fl = (*env)->GetFieldID (env, cl, "bavail", "J");
+  (*env)->SetLongField (env, jr, fl, r->bavail);
+  fl = (*env)->GetFieldID (env, cl, "files", "J");
+  (*env)->SetLongField (env, jr, fl, r->files);
+  fl = (*env)->GetFieldID (env, cl, "ffree", "J");
+  (*env)->SetLongField (env, jr, fl, r->ffree);
+  fl = (*env)->GetFieldID (env, cl, "favail", "J");
+  (*env)->SetLongField (env, jr, fl, r->favail);
+  fl = (*env)->GetFieldID (env, cl, "fsid", "J");
+  (*env)->SetLongField (env, jr, fl, r->fsid);
+  fl = (*env)->GetFieldID (env, cl, "flag", "J");
+  (*env)->SetLongField (env, jr, fl, r->flag);
+  fl = (*env)->GetFieldID (env, cl, "namemax", "J");
+  (*env)->SetLongField (env, jr, fl, r->namemax);
+  free (r);
+  return jr;
+}
+
+JNIEXPORT jobject JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rhashtable
+  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  char **r;
+  const char *val;
+
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_test0rhashtable (g, val);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  throw_exception (env, "test0rhashtable: internal error: please let us know how to make a Java HashMap from JNI bindings!");
+  return NULL;
+}
+
+JNIEXPORT jobject JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1test0rhashtableerr
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  char **r;
+
+  r = guestfs_test0rhashtableerr (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  throw_exception (env, "test0rhashtableerr: internal error: please let us know how to make a Java HashMap from JNI bindings!");
+  return NULL;
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1launch
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_launch (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1wait_1ready
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_wait_ready (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1kill_1subprocess
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_kill_subprocess (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1add_1drive
+  (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *filename;
+
+  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
+  r = guestfs_add_drive (g, filename);
+  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1add_1cdrom
+  (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *filename;
+
+  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
+  r = guestfs_add_cdrom (g, filename);
+  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1add_1drive_1ro
+  (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *filename;
+
+  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
+  r = guestfs_add_drive_ro (g, filename);
+  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1config
+  (JNIEnv *env, jobject obj, jlong jg, jstring jqemuparam, jstring jqemuvalue)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *qemuparam;
+  const char *qemuvalue;
+
+  qemuparam = (*env)->GetStringUTFChars (env, jqemuparam, NULL);
+  qemuvalue = jqemuvalue ? (*env)->GetStringUTFChars (env, jqemuvalue, NULL) : NULL;
+  r = guestfs_config (g, qemuparam, qemuvalue);
+  (*env)->ReleaseStringUTFChars (env, jqemuparam, qemuparam);
+  if (jqemuvalue)
+    (*env)->ReleaseStringUTFChars (env, jqemuvalue, qemuvalue);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1set_1qemu
+  (JNIEnv *env, jobject obj, jlong jg, jstring jqemu)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *qemu;
+
+  qemu = (*env)->GetStringUTFChars (env, jqemu, NULL);
+  r = guestfs_set_qemu (g, qemu);
+  (*env)->ReleaseStringUTFChars (env, jqemu, qemu);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1get_1qemu
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  const char *r;
+
+  r = guestfs_get_qemu (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  return (*env)->NewStringUTF (env, r);
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1set_1path
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *path;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_set_path (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1get_1path
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  const char *r;
+
+  r = guestfs_get_path (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  return (*env)->NewStringUTF (env, r);
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1set_1append
+  (JNIEnv *env, jobject obj, jlong jg, jstring jappend)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *append;
+
+  append = (*env)->GetStringUTFChars (env, jappend, NULL);
+  r = guestfs_set_append (g, append);
+  (*env)->ReleaseStringUTFChars (env, jappend, append);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1get_1append
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  const char *r;
+
+  r = guestfs_get_append (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  return (*env)->NewStringUTF (env, r);
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1set_1autosync
+  (JNIEnv *env, jobject obj, jlong jg, jboolean jautosync)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  int autosync;
+
+  autosync = jautosync;
+  r = guestfs_set_autosync (g, autosync);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1get_1autosync
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_get_autosync (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return 0;
+  }
+  return (jboolean) r;
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1set_1verbose
+  (JNIEnv *env, jobject obj, jlong jg, jboolean jverbose)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  int verbose;
+
+  verbose = jverbose;
+  r = guestfs_set_verbose (g, verbose);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1get_1verbose
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_get_verbose (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return 0;
+  }
+  return (jboolean) r;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1is_1ready
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_is_ready (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return 0;
+  }
+  return (jboolean) r;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1is_1config
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_is_config (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return 0;
+  }
+  return (jboolean) r;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1is_1launching
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_is_launching (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return 0;
+  }
+  return (jboolean) r;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1is_1busy
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_is_busy (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return 0;
+  }
+  return (jboolean) r;
+}
+
+JNIEXPORT jint JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1get_1state
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_get_state (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return 0;
+  }
+  return (jint) r;
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1set_1busy
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_set_busy (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1set_1ready
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_set_ready (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1end_1busy
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_end_busy (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1mount
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *device;
+  const char *mountpoint;
+
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
+  r = guestfs_mount (g, device, mountpoint);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1sync
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_sync (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1touch
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *path;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_touch (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1cat
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jstring jr;
+  char *r;
+  const char *path;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_cat (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  jr = (*env)->NewStringUTF (env, r);
+  free (r);
+  return jr;
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1ll
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jstring jr;
+  char *r;
+  const char *directory;
+
+  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
+  r = guestfs_ll (g, directory);
+  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  jr = (*env)->NewStringUTF (env, r);
+  free (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1ls
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  const char *directory;
+  int i;
+
+  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
+  r = guestfs_ls (g, directory);
+  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
+  free (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1list_1devices
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  int i;
+
+  r = guestfs_list_devices (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
+  free (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1list_1partitions
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  int i;
+
+  r = guestfs_list_partitions (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
+  free (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1pvs
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  int i;
+
+  r = guestfs_pvs (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
+  free (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1vgs
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  int i;
+
+  r = guestfs_vgs (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
+  free (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1lvs
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  int i;
+
+  r = guestfs_lvs (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
+  free (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1pvs_1full
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  jclass cl;
+  jfieldID fl;
+  jobject jfl;
+  struct guestfs_lvm_pv_list *r;
+  int i;
+
+  r = guestfs_pvs_full (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
+  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
+  for (i = 0; i < r->len; ++i) {
+    jfl = (*env)->AllocObject (env, cl);
+    fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
+    {
+      char s[33];
+      memcpy (s, r->val[i].pv_uuid, 32);
+      s[32] = 0;
+      fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
+      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
+    }
+    fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
+    fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
+    fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
+    fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
+    fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
+    fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
+    fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
+    fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
+    fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
+    fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
+    fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
+    fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
+    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
+  }
+  guestfs_free_lvm_pv_list (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1vgs_1full
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  jclass cl;
+  jfieldID fl;
+  jobject jfl;
+  struct guestfs_lvm_vg_list *r;
+  int i;
+
+  r = guestfs_vgs_full (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
+  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
+  for (i = 0; i < r->len; ++i) {
+    jfl = (*env)->AllocObject (env, cl);
+    fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
+    {
+      char s[33];
+      memcpy (s, r->val[i].vg_uuid, 32);
+      s[32] = 0;
+      fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
+      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
+    }
+    fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
+    fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
+    fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
+    fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
+    fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
+    fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
+    fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
+    fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
+    fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
+    fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
+    fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
+    fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
+    fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
+    fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
+    fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
+    fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
+    fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
+    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
+  }
+  guestfs_free_lvm_vg_list (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1lvs_1full
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  jclass cl;
+  jfieldID fl;
+  jobject jfl;
+  struct guestfs_lvm_lv_list *r;
+  int i;
+
+  r = guestfs_lvs_full (g);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
+  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
+  for (i = 0; i < r->len; ++i) {
+    jfl = (*env)->AllocObject (env, cl);
+    fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
+    {
+      char s[33];
+      memcpy (s, r->val[i].lv_uuid, 32);
+      s[32] = 0;
+      fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
+      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
+    }
+    fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
+    fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
+    fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
+    fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
+    fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
+    fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
+    fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
+    (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
+    fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
+    fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
+    (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
+    fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
+    (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
+    fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
+    fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
+    fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
+    fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
+    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
+    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
+  }
+  guestfs_free_lvm_lv_list (r);
+  return jr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1read_1lines
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  const char *path;
+  int i;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_read_lines (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
+  free (r);
+  return jr;
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1aug_1init
+  (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jint jflags)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *root;
+  int flags;
+
+  root = (*env)->GetStringUTFChars (env, jroot, NULL);
+  flags = jflags;
+  r = guestfs_aug_init (g, root, flags);
+  (*env)->ReleaseStringUTFChars (env, jroot, root);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1aug_1close
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_aug_close (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT jint JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1aug_1defvar
+  (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *name;
+  const char *expr;
+
+  name = (*env)->GetStringUTFChars (env, jname, NULL);
+  expr = jexpr ? (*env)->GetStringUTFChars (env, jexpr, NULL) : NULL;
+  r = guestfs_aug_defvar (g, name, expr);
+  (*env)->ReleaseStringUTFChars (env, jname, name);
+  if (jexpr)
+    (*env)->ReleaseStringUTFChars (env, jexpr, expr);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return 0;
+  }
+  return (jint) r;
+}
+
+JNIEXPORT jobject JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1aug_1defnode
+  (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr, jstring jval)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobject jr;
+  jclass cl;
+  jfieldID fl;
+  struct guestfs_int_bool *r;
+  const char *name;
+  const char *expr;
+  const char *val;
+
+  name = (*env)->GetStringUTFChars (env, jname, NULL);
+  expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_aug_defnode (g, name, expr, val);
+  (*env)->ReleaseStringUTFChars (env, jname, name);
+  (*env)->ReleaseStringUTFChars (env, jexpr, expr);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
+  jr = (*env)->AllocObject (env, cl);
+  fl = (*env)->GetFieldID (env, cl, "i", "I");
+  (*env)->SetIntField (env, jr, fl, r->i);
+  fl = (*env)->GetFieldID (env, cl, "i", "Z");
+  (*env)->SetBooleanField (env, jr, fl, r->b);
+  guestfs_free_int_bool (r);
+  return jr;
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1aug_1get
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jstring jr;
+  char *r;
+  const char *path;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_aug_get (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  jr = (*env)->NewStringUTF (env, r);
+  free (r);
+  return jr;
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1aug_1set
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jval)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *path;
+  const char *val;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  val = (*env)->GetStringUTFChars (env, jval, NULL);
+  r = guestfs_aug_set (g, path, val);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  (*env)->ReleaseStringUTFChars (env, jval, val);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1aug_1insert
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jlabel, jboolean jbefore)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *path;
+  const char *label;
+  int before;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  label = (*env)->GetStringUTFChars (env, jlabel, NULL);
+  before = jbefore;
+  r = guestfs_aug_insert (g, path, label, before);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  (*env)->ReleaseStringUTFChars (env, jlabel, label);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT jint JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1aug_1rm
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *path;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_aug_rm (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return 0;
+  }
+  return (jint) r;
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1aug_1mv
+  (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *src;
+  const char *dest;
+
+  src = (*env)->GetStringUTFChars (env, jsrc, NULL);
+  dest = (*env)->GetStringUTFChars (env, jdest, NULL);
+  r = guestfs_aug_mv (g, src, dest);
+  (*env)->ReleaseStringUTFChars (env, jsrc, src);
+  (*env)->ReleaseStringUTFChars (env, jdest, dest);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1aug_1match
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  const char *path;
+  int i;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_aug_match (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
+  free (r);
+  return jr;
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1aug_1save
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_aug_save (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1aug_1load
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+
+  r = guestfs_aug_load (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1aug_1ls
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  const char *path;
+  int i;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_aug_ls (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
+  free (r);
+  return jr;
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1rm
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *path;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_rm (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1rmdir
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *path;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_rmdir (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1rm_1rf
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *path;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_rm_rf (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1mkdir
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *path;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_mkdir (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1mkdir_1p
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *path;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_mkdir_p (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1chmod
+  (JNIEnv *env, jobject obj, jlong jg, jint jmode, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  int mode;
+  const char *path;
+
+  mode = jmode;
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_chmod (g, mode, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1chown
+  (JNIEnv *env, jobject obj, jlong jg, jint jowner, jint jgroup, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  int owner;
+  int group;
+  const char *path;
+
+  owner = jowner;
+  group = jgroup;
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_chown (g, owner, group, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1exists
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *path;
+
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_exists (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return 0;
   }
   return (jboolean) r;
 }
 
 JNIEXPORT jboolean JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1is_1busy
-  (JNIEnv *env, jobject obj, jlong jg)
+Java_com_redhat_et_libguestfs_GuestFS__1is_1file
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
+  const char *path;
 
-  r = guestfs_is_busy (g);
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_is_file (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return 0;
@@ -343,29 +2349,35 @@ Java_com_redhat_et_libguestfs_GuestFS__1is_1busy
   return (jboolean) r;
 }
 
-JNIEXPORT jint JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1get_1state
-  (JNIEnv *env, jobject obj, jlong jg)
+JNIEXPORT jboolean JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1is_1dir
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
+  const char *path;
 
-  r = guestfs_get_state (g);
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_is_dir (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return 0;
   }
-  return (jint) r;
+  return (jboolean) r;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1set_1busy
-  (JNIEnv *env, jobject obj, jlong jg)
+Java_com_redhat_et_libguestfs_GuestFS__1pvcreate
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
+  const char *device;
 
-  r = guestfs_set_busy (g);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_pvcreate (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -373,13 +2385,31 @@ Java_com_redhat_et_libguestfs_GuestFS__1set_1busy
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1set_1ready
-  (JNIEnv *env, jobject obj, jlong jg)
+Java_com_redhat_et_libguestfs_GuestFS__1vgcreate
+  (JNIEnv *env, jobject obj, jlong jg, jstring jvolgroup, jobjectArray jphysvols)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
+  const char *volgroup;
+  int physvols_len;
+  const char **physvols;
+  int i;
 
-  r = guestfs_set_ready (g);
+  volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
+  physvols_len = (*env)->GetArrayLength (env, jphysvols);
+  physvols = guestfs_safe_malloc (g, sizeof (char *) * (physvols_len+1));
+  for (i = 0; i < physvols_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
+    physvols[i] = (*env)->GetStringUTFChars (env, o, NULL);
+  }
+  physvols[physvols_len] = NULL;
+  r = guestfs_vgcreate (g, volgroup, physvols);
+  (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
+  for (i = 0; i < physvols_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
+    (*env)->ReleaseStringUTFChars (env, o, physvols[i]);
+  }
+  free (physvols);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -387,19 +2417,21 @@ Java_com_redhat_et_libguestfs_GuestFS__1set_1ready
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1mount
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
+Java_com_redhat_et_libguestfs_GuestFS__1lvcreate
+  (JNIEnv *env, jobject obj, jlong jg, jstring jlogvol, jstring jvolgroup, jint jmbytes)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *device;
-  const char *mountpoint;
+  const char *logvol;
+  const char *volgroup;
+  int mbytes;
 
-  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
-  r = guestfs_mount (g, device, mountpoint);
-  (*env)->ReleaseStringUTFChars (env, jdevice, device);
-  (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
+  logvol = (*env)->GetStringUTFChars (env, jlogvol, NULL);
+  volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
+  mbytes = jmbytes;
+  r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
+  (*env)->ReleaseStringUTFChars (env, jlogvol, logvol);
+  (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -407,13 +2439,19 @@ Java_com_redhat_et_libguestfs_GuestFS__1mount
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1sync
-  (JNIEnv *env, jobject obj, jlong jg)
+Java_com_redhat_et_libguestfs_GuestFS__1mkfs
+  (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
+  const char *fstype;
+  const char *device;
 
-  r = guestfs_sync (g);
+  fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_mkfs (g, fstype, device);
+  (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -421,67 +2459,85 @@ Java_com_redhat_et_libguestfs_GuestFS__1sync
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1touch
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+Java_com_redhat_et_libguestfs_GuestFS__1sfdisk
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jcyls, jint jheads, jint jsectors, jobjectArray jlines)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *path;
+  const char *device;
+  int cyls;
+  int heads;
+  int sectors;
+  int lines_len;
+  const char **lines;
+  int i;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_touch (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  cyls = jcyls;
+  heads = jheads;
+  sectors = jsectors;
+  lines_len = (*env)->GetArrayLength (env, jlines);
+  lines = guestfs_safe_malloc (g, sizeof (char *) * (lines_len+1));
+  for (i = 0; i < lines_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
+    lines[i] = (*env)->GetStringUTFChars (env, o, NULL);
+  }
+  lines[lines_len] = NULL;
+  r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  for (i = 0; i < lines_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
+    (*env)->ReleaseStringUTFChars (env, o, lines[i]);
+  }
+  free (lines);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
   }
 }
 
-JNIEXPORT jstring JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1cat
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1write_1file
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jcontent, jint jsize)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jstring jr;
-  char *r;
+  int r;
   const char *path;
+  const char *content;
+  int size;
 
   path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_cat (g, path);
+  content = (*env)->GetStringUTFChars (env, jcontent, NULL);
+  size = jsize;
+  r = guestfs_write_file (g, path, content, size);
   (*env)->ReleaseStringUTFChars (env, jpath, path);
-  if (r == NULL) {
+  (*env)->ReleaseStringUTFChars (env, jcontent, content);
+  if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return NULL;
+    return ;
   }
-  jr = (*env)->NewStringUTF (env, r);
-  free (r);
-  return jr;
 }
 
-JNIEXPORT jstring JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1ll
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1umount
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpathordevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jstring jr;
-  char *r;
-  const char *directory;
+  int r;
+  const char *pathordevice;
 
-  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
-  r = guestfs_ll (g, directory);
-  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
-  if (r == NULL) {
+  pathordevice = (*env)->GetStringUTFChars (env, jpathordevice, NULL);
+  r = guestfs_umount (g, pathordevice);
+  (*env)->ReleaseStringUTFChars (env, jpathordevice, pathordevice);
+  if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return NULL;
+    return ;
   }
-  jr = (*env)->NewStringUTF (env, r);
-  free (r);
-  return jr;
 }
 
 JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1ls
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
+Java_com_redhat_et_libguestfs_GuestFS__1mounts
+  (JNIEnv *env, jobject obj, jlong jg)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   jobjectArray jr;
@@ -489,12 +2545,9 @@ Java_com_redhat_et_libguestfs_GuestFS__1ls
   jclass cl;
   jstring jstr;
   char **r;
-  const char *directory;
   int i;
 
-  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
-  r = guestfs_ls (g, directory);
-  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
+  r = guestfs_mounts (g);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
@@ -512,129 +2565,91 @@ Java_com_redhat_et_libguestfs_GuestFS__1ls
   return jr;
 }
 
-JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1list_1devices
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1umount_1all
   (JNIEnv *env, jobject obj, jlong jg)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobjectArray jr;
-  int r_len;
-  jclass cl;
-  jstring jstr;
-  char **r;
-  int i;
+  int r;
 
-  r = guestfs_list_devices (g);
-  if (r == NULL) {
+  r = guestfs_umount_all (g);
+  if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return NULL;
-  }
-  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
-  cl = (*env)->FindClass (env, "java/lang/String");
-  jstr = (*env)->NewStringUTF (env, "");
-  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
-  for (i = 0; i < r_len; ++i) {
-    jstr = (*env)->NewStringUTF (env, r[i]);
-    (*env)->SetObjectArrayElement (env, jr, i, jstr);
-    free (r[i]);
+    return ;
   }
-  free (r);
-  return jr;
 }
 
-JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1list_1partitions
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1lvm_1remove_1all
   (JNIEnv *env, jobject obj, jlong jg)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobjectArray jr;
-  int r_len;
-  jclass cl;
-  jstring jstr;
-  char **r;
-  int i;
+  int r;
 
-  r = guestfs_list_partitions (g);
-  if (r == NULL) {
+  r = guestfs_lvm_remove_all (g);
+  if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return NULL;
-  }
-  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
-  cl = (*env)->FindClass (env, "java/lang/String");
-  jstr = (*env)->NewStringUTF (env, "");
-  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
-  for (i = 0; i < r_len; ++i) {
-    jstr = (*env)->NewStringUTF (env, r[i]);
-    (*env)->SetObjectArrayElement (env, jr, i, jstr);
-    free (r[i]);
+    return ;
   }
-  free (r);
-  return jr;
 }
 
-JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1pvs
-  (JNIEnv *env, jobject obj, jlong jg)
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1file
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobjectArray jr;
-  int r_len;
-  jclass cl;
-  jstring jstr;
-  char **r;
-  int i;
+  jstring jr;
+  char *r;
+  const char *path;
 
-  r = guestfs_pvs (g);
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_file (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
   }
-  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
-  cl = (*env)->FindClass (env, "java/lang/String");
-  jstr = (*env)->NewStringUTF (env, "");
-  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
-  for (i = 0; i < r_len; ++i) {
-    jstr = (*env)->NewStringUTF (env, r[i]);
-    (*env)->SetObjectArrayElement (env, jr, i, jstr);
-    free (r[i]);
-  }
+  jr = (*env)->NewStringUTF (env, r);
   free (r);
   return jr;
 }
 
-JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1vgs
-  (JNIEnv *env, jobject obj, jlong jg)
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1command
+  (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobjectArray jr;
-  int r_len;
-  jclass cl;
-  jstring jstr;
-  char **r;
+  jstring jr;
+  char *r;
+  int arguments_len;
+  const char **arguments;
   int i;
 
-  r = guestfs_vgs (g);
+  arguments_len = (*env)->GetArrayLength (env, jarguments);
+  arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
+  for (i = 0; i < arguments_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
+    arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
+  }
+  arguments[arguments_len] = NULL;
+  r = guestfs_command (g, arguments);
+  for (i = 0; i < arguments_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
+    (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
+  }
+  free (arguments);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
   }
-  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
-  cl = (*env)->FindClass (env, "java/lang/String");
-  jstr = (*env)->NewStringUTF (env, "");
-  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
-  for (i = 0; i < r_len; ++i) {
-    jstr = (*env)->NewStringUTF (env, r[i]);
-    (*env)->SetObjectArrayElement (env, jr, i, jstr);
-    free (r[i]);
-  }
+  jr = (*env)->NewStringUTF (env, r);
   free (r);
   return jr;
 }
 
 JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1lvs
-  (JNIEnv *env, jobject obj, jlong jg)
+Java_com_redhat_et_libguestfs_GuestFS__1command_1lines
+  (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   jobjectArray jr;
@@ -642,9 +2657,23 @@ Java_com_redhat_et_libguestfs_GuestFS__1lvs
   jclass cl;
   jstring jstr;
   char **r;
+  int arguments_len;
+  const char **arguments;
   int i;
 
-  r = guestfs_lvs (g);
+  arguments_len = (*env)->GetArrayLength (env, jarguments);
+  arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
+  for (i = 0; i < arguments_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
+    arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
+  }
+  arguments[arguments_len] = NULL;
+  r = guestfs_command_lines (g, arguments);
+  for (i = 0; i < arguments_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
+    (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
+  }
+  free (arguments);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
@@ -662,246 +2691,182 @@ Java_com_redhat_et_libguestfs_GuestFS__1lvs
   return jr;
 }
 
-JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1pvs_1full
-  (JNIEnv *env, jobject obj, jlong jg)
+JNIEXPORT jobject JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1stat
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobjectArray jr;
+  jobject jr;
   jclass cl;
   jfieldID fl;
-  jobject jfl;
-  struct guestfs_lvm_pv_list *r;
-  int i;
+  struct guestfs_stat *r;
+  const char *path;
 
-  r = guestfs_pvs_full (g);
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_stat (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
   }
-  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
-  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
-  for (i = 0; i < r->len; ++i) {
-    jfl = (*env)->AllocObject (env, cl);
-    fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
-    {
-      char s[33];
-      memcpy (s, r->val[i].pv_uuid, 32);
-      s[32] = 0;
-      fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
-      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
-    }
-    fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
-    fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
-    fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
-    fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
-    fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
-    fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
-    fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
-    fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
-    fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
-    fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
-    fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
-    fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
-    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
-  }
-  guestfs_free_lvm_pv_list (r);
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
+  jr = (*env)->AllocObject (env, cl);
+  fl = (*env)->GetFieldID (env, cl, "dev", "J");
+  (*env)->SetLongField (env, jr, fl, r->dev);
+  fl = (*env)->GetFieldID (env, cl, "ino", "J");
+  (*env)->SetLongField (env, jr, fl, r->ino);
+  fl = (*env)->GetFieldID (env, cl, "mode", "J");
+  (*env)->SetLongField (env, jr, fl, r->mode);
+  fl = (*env)->GetFieldID (env, cl, "nlink", "J");
+  (*env)->SetLongField (env, jr, fl, r->nlink);
+  fl = (*env)->GetFieldID (env, cl, "uid", "J");
+  (*env)->SetLongField (env, jr, fl, r->uid);
+  fl = (*env)->GetFieldID (env, cl, "gid", "J");
+  (*env)->SetLongField (env, jr, fl, r->gid);
+  fl = (*env)->GetFieldID (env, cl, "rdev", "J");
+  (*env)->SetLongField (env, jr, fl, r->rdev);
+  fl = (*env)->GetFieldID (env, cl, "size", "J");
+  (*env)->SetLongField (env, jr, fl, r->size);
+  fl = (*env)->GetFieldID (env, cl, "blksize", "J");
+  (*env)->SetLongField (env, jr, fl, r->blksize);
+  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
+  (*env)->SetLongField (env, jr, fl, r->blocks);
+  fl = (*env)->GetFieldID (env, cl, "atime", "J");
+  (*env)->SetLongField (env, jr, fl, r->atime);
+  fl = (*env)->GetFieldID (env, cl, "mtime", "J");
+  (*env)->SetLongField (env, jr, fl, r->mtime);
+  fl = (*env)->GetFieldID (env, cl, "ctime", "J");
+  (*env)->SetLongField (env, jr, fl, r->ctime);
+  free (r);
   return jr;
 }
 
-JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1vgs_1full
-  (JNIEnv *env, jobject obj, jlong jg)
+JNIEXPORT jobject JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1lstat
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobjectArray jr;
+  jobject jr;
   jclass cl;
   jfieldID fl;
-  jobject jfl;
-  struct guestfs_lvm_vg_list *r;
-  int i;
+  struct guestfs_stat *r;
+  const char *path;
 
-  r = guestfs_vgs_full (g);
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_lstat (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
   }
-  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
-  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
-  for (i = 0; i < r->len; ++i) {
-    jfl = (*env)->AllocObject (env, cl);
-    fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
-    {
-      char s[33];
-      memcpy (s, r->val[i].vg_uuid, 32);
-      s[32] = 0;
-      fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
-      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
-    }
-    fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
-    fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
-    fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
-    fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
-    fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
-    fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
-    fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
-    fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
-    fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
-    fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
-    fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
-    fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
-    fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
-    fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
-    fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
-    fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
-    fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
-    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
-  }
-  guestfs_free_lvm_vg_list (r);
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
+  jr = (*env)->AllocObject (env, cl);
+  fl = (*env)->GetFieldID (env, cl, "dev", "J");
+  (*env)->SetLongField (env, jr, fl, r->dev);
+  fl = (*env)->GetFieldID (env, cl, "ino", "J");
+  (*env)->SetLongField (env, jr, fl, r->ino);
+  fl = (*env)->GetFieldID (env, cl, "mode", "J");
+  (*env)->SetLongField (env, jr, fl, r->mode);
+  fl = (*env)->GetFieldID (env, cl, "nlink", "J");
+  (*env)->SetLongField (env, jr, fl, r->nlink);
+  fl = (*env)->GetFieldID (env, cl, "uid", "J");
+  (*env)->SetLongField (env, jr, fl, r->uid);
+  fl = (*env)->GetFieldID (env, cl, "gid", "J");
+  (*env)->SetLongField (env, jr, fl, r->gid);
+  fl = (*env)->GetFieldID (env, cl, "rdev", "J");
+  (*env)->SetLongField (env, jr, fl, r->rdev);
+  fl = (*env)->GetFieldID (env, cl, "size", "J");
+  (*env)->SetLongField (env, jr, fl, r->size);
+  fl = (*env)->GetFieldID (env, cl, "blksize", "J");
+  (*env)->SetLongField (env, jr, fl, r->blksize);
+  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
+  (*env)->SetLongField (env, jr, fl, r->blocks);
+  fl = (*env)->GetFieldID (env, cl, "atime", "J");
+  (*env)->SetLongField (env, jr, fl, r->atime);
+  fl = (*env)->GetFieldID (env, cl, "mtime", "J");
+  (*env)->SetLongField (env, jr, fl, r->mtime);
+  fl = (*env)->GetFieldID (env, cl, "ctime", "J");
+  (*env)->SetLongField (env, jr, fl, r->ctime);
+  free (r);
   return jr;
 }
 
-JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1lvs_1full
-  (JNIEnv *env, jobject obj, jlong jg)
+JNIEXPORT jobject JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1statvfs
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobjectArray jr;
+  jobject jr;
   jclass cl;
   jfieldID fl;
-  jobject jfl;
-  struct guestfs_lvm_lv_list *r;
-  int i;
+  struct guestfs_statvfs *r;
+  const char *path;
 
-  r = guestfs_lvs_full (g);
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_statvfs (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
   }
-  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
-  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
-  for (i = 0; i < r->len; ++i) {
-    jfl = (*env)->AllocObject (env, cl);
-    fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
-    {
-      char s[33];
-      memcpy (s, r->val[i].lv_uuid, 32);
-      s[32] = 0;
-      fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
-      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
-    }
-    fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
-    fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
-    fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
-    fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
-    fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
-    fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
-    fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
-    (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
-    fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
-    fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
-    (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
-    fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
-    (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
-    fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
-    fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
-    fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
-    fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
-    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
-    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
-  }
-  guestfs_free_lvm_lv_list (r);
+  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
+  jr = (*env)->AllocObject (env, cl);
+  fl = (*env)->GetFieldID (env, cl, "bsize", "J");
+  (*env)->SetLongField (env, jr, fl, r->bsize);
+  fl = (*env)->GetFieldID (env, cl, "frsize", "J");
+  (*env)->SetLongField (env, jr, fl, r->frsize);
+  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
+  (*env)->SetLongField (env, jr, fl, r->blocks);
+  fl = (*env)->GetFieldID (env, cl, "bfree", "J");
+  (*env)->SetLongField (env, jr, fl, r->bfree);
+  fl = (*env)->GetFieldID (env, cl, "bavail", "J");
+  (*env)->SetLongField (env, jr, fl, r->bavail);
+  fl = (*env)->GetFieldID (env, cl, "files", "J");
+  (*env)->SetLongField (env, jr, fl, r->files);
+  fl = (*env)->GetFieldID (env, cl, "ffree", "J");
+  (*env)->SetLongField (env, jr, fl, r->ffree);
+  fl = (*env)->GetFieldID (env, cl, "favail", "J");
+  (*env)->SetLongField (env, jr, fl, r->favail);
+  fl = (*env)->GetFieldID (env, cl, "fsid", "J");
+  (*env)->SetLongField (env, jr, fl, r->fsid);
+  fl = (*env)->GetFieldID (env, cl, "flag", "J");
+  (*env)->SetLongField (env, jr, fl, r->flag);
+  fl = (*env)->GetFieldID (env, cl, "namemax", "J");
+  (*env)->SetLongField (env, jr, fl, r->namemax);
+  free (r);
   return jr;
 }
 
-JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1read_1lines
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+JNIEXPORT jobject JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1tune2fs_1l
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobjectArray jr;
-  int r_len;
-  jclass cl;
-  jstring jstr;
   char **r;
-  const char *path;
-  int i;
+  const char *device;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_read_lines (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_tune2fs_l (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
   }
-  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
-  cl = (*env)->FindClass (env, "java/lang/String");
-  jstr = (*env)->NewStringUTF (env, "");
-  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
-  for (i = 0; i < r_len; ++i) {
-    jstr = (*env)->NewStringUTF (env, r[i]);
-    (*env)->SetObjectArrayElement (env, jr, i, jstr);
-    free (r[i]);
-  }
-  free (r);
-  return jr;
+  throw_exception (env, "tune2fs_l: internal error: please let us know how to make a Java HashMap from JNI bindings!");
+  return NULL;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1aug_1init
-  (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jint jflags)
+Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setro
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *root;
-  int flags;
+  const char *device;
 
-  root = (*env)->GetStringUTFChars (env, jroot, NULL);
-  flags = jflags;
-  r = guestfs_aug_init (g, root, flags);
-  (*env)->ReleaseStringUTFChars (env, jroot, root);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_blockdev_setro (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -909,33 +2874,51 @@ Java_com_redhat_et_libguestfs_GuestFS__1aug_1init
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1aug_1close
-  (JNIEnv *env, jobject obj, jlong jg)
+Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setrw
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
+  const char *device;
 
-  r = guestfs_aug_close (g);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_blockdev_setrw (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
   }
 }
 
+JNIEXPORT jboolean JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getro
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *device;
+
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_blockdev_getro (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return 0;
+  }
+  return (jboolean) r;
+}
+
 JNIEXPORT jint JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1aug_1defvar
-  (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr)
+Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getss
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *name;
-  const char *expr;
+  const char *device;
 
-  name = (*env)->GetStringUTFChars (env, jname, NULL);
-  expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
-  r = guestfs_aug_defvar (g, name, expr);
-  (*env)->ReleaseStringUTFChars (env, jname, name);
-  (*env)->ReleaseStringUTFChars (env, jexpr, expr);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_blockdev_getss (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return 0;
@@ -943,75 +2926,90 @@ Java_com_redhat_et_libguestfs_GuestFS__1aug_1defvar
   return (jint) r;
 }
 
-JNIEXPORT jobject JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1aug_1defnode
-  (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr, jstring jval)
+JNIEXPORT jint JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getbsz
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobject jr;
-  jclass cl;
-  jfieldID fl;
-  struct guestfs_int_bool *r;
-  const char *name;
-  const char *expr;
-  const char *val;
+  int r;
+  const char *device;
 
-  name = (*env)->GetStringUTFChars (env, jname, NULL);
-  expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
-  val = (*env)->GetStringUTFChars (env, jval, NULL);
-  r = guestfs_aug_defnode (g, name, expr, val);
-  (*env)->ReleaseStringUTFChars (env, jname, name);
-  (*env)->ReleaseStringUTFChars (env, jexpr, expr);
-  (*env)->ReleaseStringUTFChars (env, jval, val);
-  if (r == NULL) {
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_blockdev_getbsz (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return NULL;
+    return 0;
   }
-  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
-  jr = (*env)->AllocObject (env, cl);
-  fl = (*env)->GetFieldID (env, cl, "i", "I");
-  (*env)->SetIntField (env, jr, fl, r->i);
-  fl = (*env)->GetFieldID (env, cl, "i", "Z");
-  (*env)->SetBooleanField (env, jr, fl, r->b);
-  guestfs_free_int_bool (r);
-  return jr;
+  return (jint) r;
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setbsz
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jblocksize)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *device;
+  int blocksize;
+
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  blocksize = jblocksize;
+  r = guestfs_blockdev_setbsz (g, device, blocksize);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
+  }
+}
+
+JNIEXPORT jlong JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsz
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int64_t r;
+  const char *device;
+
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_blockdev_getsz (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return 0;
+  }
+  return (jlong) r;
 }
 
-JNIEXPORT jstring JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1aug_1get
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+JNIEXPORT jlong JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsize64
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jstring jr;
-  char *r;
-  const char *path;
+  int64_t r;
+  const char *device;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_aug_get (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
-  if (r == NULL) {
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_blockdev_getsize64 (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return NULL;
+    return 0;
   }
-  jr = (*env)->NewStringUTF (env, r);
-  free (r);
-  return jr;
+  return (jlong) r;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1aug_1set
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jval)
+Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1flushbufs
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *path;
-  const char *val;
+  const char *device;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  val = (*env)->GetStringUTFChars (env, jval, NULL);
-  r = guestfs_aug_set (g, path, val);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
-  (*env)->ReleaseStringUTFChars (env, jval, val);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_blockdev_flushbufs (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -1019,106 +3017,100 @@ Java_com_redhat_et_libguestfs_GuestFS__1aug_1set
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1aug_1insert
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jlabel, jboolean jbefore)
+Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1rereadpt
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *path;
-  const char *label;
-  int before;
+  const char *device;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  label = (*env)->GetStringUTFChars (env, jlabel, NULL);
-  before = jbefore;
-  r = guestfs_aug_insert (g, path, label, before);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
-  (*env)->ReleaseStringUTFChars (env, jlabel, label);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_blockdev_rereadpt (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
   }
 }
 
-JNIEXPORT jint JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1aug_1rm
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1upload
+  (JNIEnv *env, jobject obj, jlong jg, jstring jfilename, jstring jremotefilename)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *path;
+  const char *filename;
+  const char *remotefilename;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_aug_rm (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
+  remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
+  r = guestfs_upload (g, filename, remotefilename);
+  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
+  (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return 0;
+    return ;
   }
-  return (jint) r;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1aug_1mv
-  (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
+Java_com_redhat_et_libguestfs_GuestFS__1download
+  (JNIEnv *env, jobject obj, jlong jg, jstring jremotefilename, jstring jfilename)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *src;
-  const char *dest;
+  const char *remotefilename;
+  const char *filename;
 
-  src = (*env)->GetStringUTFChars (env, jsrc, NULL);
-  dest = (*env)->GetStringUTFChars (env, jdest, NULL);
-  r = guestfs_aug_mv (g, src, dest);
-  (*env)->ReleaseStringUTFChars (env, jsrc, src);
-  (*env)->ReleaseStringUTFChars (env, jdest, dest);
+  remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
+  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
+  r = guestfs_download (g, remotefilename, filename);
+  (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
+  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
   }
 }
 
-JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1aug_1match
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1checksum
+  (JNIEnv *env, jobject obj, jlong jg, jstring jcsumtype, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobjectArray jr;
-  int r_len;
-  jclass cl;
-  jstring jstr;
-  char **r;
+  jstring jr;
+  char *r;
+  const char *csumtype;
   const char *path;
-  int i;
 
+  csumtype = (*env)->GetStringUTFChars (env, jcsumtype, NULL);
   path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_aug_match (g, path);
+  r = guestfs_checksum (g, csumtype, path);
+  (*env)->ReleaseStringUTFChars (env, jcsumtype, csumtype);
   (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
   }
-  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
-  cl = (*env)->FindClass (env, "java/lang/String");
-  jstr = (*env)->NewStringUTF (env, "");
-  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
-  for (i = 0; i < r_len; ++i) {
-    jstr = (*env)->NewStringUTF (env, r[i]);
-    (*env)->SetObjectArrayElement (env, jr, i, jstr);
-    free (r[i]);
-  }
+  jr = (*env)->NewStringUTF (env, r);
   free (r);
   return jr;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1aug_1save
-  (JNIEnv *env, jobject obj, jlong jg)
+Java_com_redhat_et_libguestfs_GuestFS__1tar_1in
+  (JNIEnv *env, jobject obj, jlong jg, jstring jtarfile, jstring jdirectory)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
+  const char *tarfile;
+  const char *directory;
 
-  r = guestfs_aug_save (g);
+  tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
+  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
+  r = guestfs_tar_in (g, tarfile, directory);
+  (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
+  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -1126,63 +3118,59 @@ Java_com_redhat_et_libguestfs_GuestFS__1aug_1save
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1aug_1load
-  (JNIEnv *env, jobject obj, jlong jg)
+Java_com_redhat_et_libguestfs_GuestFS__1tar_1out
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarfile)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
+  const char *directory;
+  const char *tarfile;
 
-  r = guestfs_aug_load (g);
+  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
+  tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
+  r = guestfs_tar_out (g, directory, tarfile);
+  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
+  (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
   }
 }
 
-JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1aug_1ls
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1tgz_1in
+  (JNIEnv *env, jobject obj, jlong jg, jstring jtarball, jstring jdirectory)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobjectArray jr;
-  int r_len;
-  jclass cl;
-  jstring jstr;
-  char **r;
-  const char *path;
-  int i;
+  int r;
+  const char *tarball;
+  const char *directory;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_aug_ls (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
-  if (r == NULL) {
+  tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
+  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
+  r = guestfs_tgz_in (g, tarball, directory);
+  (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
+  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
+  if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return NULL;
-  }
-  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
-  cl = (*env)->FindClass (env, "java/lang/String");
-  jstr = (*env)->NewStringUTF (env, "");
-  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
-  for (i = 0; i < r_len; ++i) {
-    jstr = (*env)->NewStringUTF (env, r[i]);
-    (*env)->SetObjectArrayElement (env, jr, i, jstr);
-    free (r[i]);
+    return ;
   }
-  free (r);
-  return jr;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1rm
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+Java_com_redhat_et_libguestfs_GuestFS__1tgz_1out
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarball)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *path;
+  const char *directory;
+  const char *tarball;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_rm (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
+  tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
+  r = guestfs_tgz_out (g, directory, tarball);
+  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
+  (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -1190,16 +3178,19 @@ Java_com_redhat_et_libguestfs_GuestFS__1rm
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1rmdir
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+Java_com_redhat_et_libguestfs_GuestFS__1mount_1ro
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *path;
+  const char *device;
+  const char *mountpoint;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_rmdir (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
+  r = guestfs_mount_ro (g, device, mountpoint);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -1207,16 +3198,22 @@ Java_com_redhat_et_libguestfs_GuestFS__1rmdir
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1rm_1rf
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+Java_com_redhat_et_libguestfs_GuestFS__1mount_1options
+  (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jdevice, jstring jmountpoint)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *path;
+  const char *options;
+  const char *device;
+  const char *mountpoint;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_rm_rf (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  options = (*env)->GetStringUTFChars (env, joptions, NULL);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
+  r = guestfs_mount_options (g, options, device, mountpoint);
+  (*env)->ReleaseStringUTFChars (env, joptions, options);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -1224,52 +3221,78 @@ Java_com_redhat_et_libguestfs_GuestFS__1rm_1rf
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1mkdir
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+Java_com_redhat_et_libguestfs_GuestFS__1mount_1vfs
+  (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jvfstype, jstring jdevice, jstring jmountpoint)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *path;
+  const char *options;
+  const char *vfstype;
+  const char *device;
+  const char *mountpoint;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_mkdir (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  options = (*env)->GetStringUTFChars (env, joptions, NULL);
+  vfstype = (*env)->GetStringUTFChars (env, jvfstype, NULL);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
+  r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
+  (*env)->ReleaseStringUTFChars (env, joptions, options);
+  (*env)->ReleaseStringUTFChars (env, jvfstype, vfstype);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
   }
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1mkdir_1p
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1debug
+  (JNIEnv *env, jobject obj, jlong jg, jstring jsubcmd, jobjectArray jextraargs)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  const char *path;
+  jstring jr;
+  char *r;
+  const char *subcmd;
+  int extraargs_len;
+  const char **extraargs;
+  int i;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_mkdir_p (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
-  if (r == -1) {
+  subcmd = (*env)->GetStringUTFChars (env, jsubcmd, NULL);
+  extraargs_len = (*env)->GetArrayLength (env, jextraargs);
+  extraargs = guestfs_safe_malloc (g, sizeof (char *) * (extraargs_len+1));
+  for (i = 0; i < extraargs_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
+    extraargs[i] = (*env)->GetStringUTFChars (env, o, NULL);
+  }
+  extraargs[extraargs_len] = NULL;
+  r = guestfs_debug (g, subcmd, extraargs);
+  (*env)->ReleaseStringUTFChars (env, jsubcmd, subcmd);
+  for (i = 0; i < extraargs_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
+    (*env)->ReleaseStringUTFChars (env, o, extraargs[i]);
+  }
+  free (extraargs);
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return NULL;
   }
+  jr = (*env)->NewStringUTF (env, r);
+  free (r);
+  return jr;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1chmod
-  (JNIEnv *env, jobject obj, jlong jg, jint jmode, jstring jpath)
+Java_com_redhat_et_libguestfs_GuestFS__1lvremove
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  int mode;
-  const char *path;
+  const char *device;
 
-  mode = jmode;
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_chmod (g, mode, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_lvremove (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -1277,153 +3300,123 @@ Java_com_redhat_et_libguestfs_GuestFS__1chmod
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1chown
-  (JNIEnv *env, jobject obj, jlong jg, jint jowner, jint jgroup, jstring jpath)
+Java_com_redhat_et_libguestfs_GuestFS__1vgremove
+  (JNIEnv *env, jobject obj, jlong jg, jstring jvgname)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  int owner;
-  int group;
-  const char *path;
+  const char *vgname;
 
-  owner = jowner;
-  group = jgroup;
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_chown (g, owner, group, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  vgname = (*env)->GetStringUTFChars (env, jvgname, NULL);
+  r = guestfs_vgremove (g, vgname);
+  (*env)->ReleaseStringUTFChars (env, jvgname, vgname);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
   }
 }
 
-JNIEXPORT jboolean JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1exists
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
-{
-  guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  const char *path;
-
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_exists (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
-  if (r == -1) {
-    throw_exception (env, guestfs_last_error (g));
-    return 0;
-  }
-  return (jboolean) r;
-}
-
-JNIEXPORT jboolean JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1is_1file
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1pvremove
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *path;
+  const char *device;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_is_file (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_pvremove (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return 0;
+    return ;
   }
-  return (jboolean) r;
 }
 
-JNIEXPORT jboolean JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1is_1dir
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1set_1e2label
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jlabel)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *path;
+  const char *device;
+  const char *label;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_is_dir (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  label = (*env)->GetStringUTFChars (env, jlabel, NULL);
+  r = guestfs_set_e2label (g, device, label);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  (*env)->ReleaseStringUTFChars (env, jlabel, label);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return 0;
+    return ;
   }
-  return (jboolean) r;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1pvcreate
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1get_1e2label
   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
+  jstring jr;
+  char *r;
   const char *device;
 
   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_pvcreate (g, device);
+  r = guestfs_get_e2label (g, device);
   (*env)->ReleaseStringUTFChars (env, jdevice, device);
-  if (r == -1) {
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return NULL;
   }
+  jr = (*env)->NewStringUTF (env, r);
+  free (r);
+  return jr;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1vgcreate
-  (JNIEnv *env, jobject obj, jlong jg, jstring jvolgroup, jobjectArray jphysvols)
+Java_com_redhat_et_libguestfs_GuestFS__1set_1e2uuid
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring juuid)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *volgroup;
-  int physvols_len;
-  const char **physvols;
-  int i;
+  const char *device;
+  const char *uuid;
 
-  volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
-  physvols_len = (*env)->GetArrayLength (env, jphysvols);
-  physvols = guestfs_safe_malloc (g, sizeof (char *) * (physvols_len+1));
-  for (i = 0; i < physvols_len; ++i) {
-    jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
-    physvols[i] = (*env)->GetStringUTFChars (env, o, NULL);
-  }
-  physvols[physvols_len] = NULL;
-  r = guestfs_vgcreate (g, volgroup, physvols);
-  (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
-  for (i = 0; i < physvols_len; ++i) {
-    jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
-    (*env)->ReleaseStringUTFChars (env, o, physvols[i]);
-  }
-  free (physvols);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  uuid = (*env)->GetStringUTFChars (env, juuid, NULL);
+  r = guestfs_set_e2uuid (g, device, uuid);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  (*env)->ReleaseStringUTFChars (env, juuid, uuid);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
   }
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1lvcreate
-  (JNIEnv *env, jobject obj, jlong jg, jstring jlogvol, jstring jvolgroup, jint jmbytes)
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1get_1e2uuid
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  const char *logvol;
-  const char *volgroup;
-  int mbytes;
+  jstring jr;
+  char *r;
+  const char *device;
 
-  logvol = (*env)->GetStringUTFChars (env, jlogvol, NULL);
-  volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
-  mbytes = jmbytes;
-  r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
-  (*env)->ReleaseStringUTFChars (env, jlogvol, logvol);
-  (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
-  if (r == -1) {
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_get_e2uuid (g, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return NULL;
   }
+  jr = (*env)->NewStringUTF (env, r);
+  free (r);
+  return jr;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1mkfs
+JNIEXPORT jint JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1fsck
   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
@@ -1433,47 +3426,27 @@ Java_com_redhat_et_libguestfs_GuestFS__1mkfs
 
   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_mkfs (g, fstype, device);
+  r = guestfs_fsck (g, fstype, device);
   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
   (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return 0;
   }
+  return (jint) r;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1sfdisk
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jcyls, jint jheads, jint jsectors, jobjectArray jlines)
+Java_com_redhat_et_libguestfs_GuestFS__1zero
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
   const char *device;
-  int cyls;
-  int heads;
-  int sectors;
-  int lines_len;
-  const char **lines;
-  int i;
 
   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  cyls = jcyls;
-  heads = jheads;
-  sectors = jsectors;
-  lines_len = (*env)->GetArrayLength (env, jlines);
-  lines = guestfs_safe_malloc (g, sizeof (char *) * (lines_len+1));
-  for (i = 0; i < lines_len; ++i) {
-    jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
-    lines[i] = (*env)->GetStringUTFChars (env, o, NULL);
-  }
-  lines[lines_len] = NULL;
-  r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
+  r = guestfs_zero (g, device);
   (*env)->ReleaseStringUTFChars (env, jdevice, device);
-  for (i = 0; i < lines_len; ++i) {
-    jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
-    (*env)->ReleaseStringUTFChars (env, o, lines[i]);
-  }
-  free (lines);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -1481,21 +3454,19 @@ Java_com_redhat_et_libguestfs_GuestFS__1sfdisk
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1write_1file
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jcontent, jint jsize)
+Java_com_redhat_et_libguestfs_GuestFS__1grub_1install
+  (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *path;
-  const char *content;
-  int size;
+  const char *root;
+  const char *device;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  content = (*env)->GetStringUTFChars (env, jcontent, NULL);
-  size = jsize;
-  r = guestfs_write_file (g, path, content, size);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
-  (*env)->ReleaseStringUTFChars (env, jcontent, content);
+  root = (*env)->GetStringUTFChars (env, jroot, NULL);
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_grub_install (g, root, device);
+  (*env)->ReleaseStringUTFChars (env, jroot, root);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -1503,60 +3474,59 @@ Java_com_redhat_et_libguestfs_GuestFS__1write_1file
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1umount
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpathordevice)
+Java_com_redhat_et_libguestfs_GuestFS__1cp
+  (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *pathordevice;
+  const char *src;
+  const char *dest;
 
-  pathordevice = (*env)->GetStringUTFChars (env, jpathordevice, NULL);
-  r = guestfs_umount (g, pathordevice);
-  (*env)->ReleaseStringUTFChars (env, jpathordevice, pathordevice);
+  src = (*env)->GetStringUTFChars (env, jsrc, NULL);
+  dest = (*env)->GetStringUTFChars (env, jdest, NULL);
+  r = guestfs_cp (g, src, dest);
+  (*env)->ReleaseStringUTFChars (env, jsrc, src);
+  (*env)->ReleaseStringUTFChars (env, jdest, dest);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
   }
 }
 
-JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1mounts
-  (JNIEnv *env, jobject obj, jlong jg)
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1cp_1a
+  (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobjectArray jr;
-  int r_len;
-  jclass cl;
-  jstring jstr;
-  char **r;
-  int i;
+  int r;
+  const char *src;
+  const char *dest;
 
-  r = guestfs_mounts (g);
-  if (r == NULL) {
+  src = (*env)->GetStringUTFChars (env, jsrc, NULL);
+  dest = (*env)->GetStringUTFChars (env, jdest, NULL);
+  r = guestfs_cp_a (g, src, dest);
+  (*env)->ReleaseStringUTFChars (env, jsrc, src);
+  (*env)->ReleaseStringUTFChars (env, jdest, dest);
+  if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return NULL;
-  }
-  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
-  cl = (*env)->FindClass (env, "java/lang/String");
-  jstr = (*env)->NewStringUTF (env, "");
-  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
-  for (i = 0; i < r_len; ++i) {
-    jstr = (*env)->NewStringUTF (env, r[i]);
-    (*env)->SetObjectArrayElement (env, jr, i, jstr);
-    free (r[i]);
+    return ;
   }
-  free (r);
-  return jr;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1umount_1all
-  (JNIEnv *env, jobject obj, jlong jg)
+Java_com_redhat_et_libguestfs_GuestFS__1mv
+  (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
+  const char *src;
+  const char *dest;
 
-  r = guestfs_umount_all (g);
+  src = (*env)->GetStringUTFChars (env, jsrc, NULL);
+  dest = (*env)->GetStringUTFChars (env, jdest, NULL);
+  r = guestfs_mv (g, src, dest);
+  (*env)->ReleaseStringUTFChars (env, jsrc, src);
+  (*env)->ReleaseStringUTFChars (env, jdest, dest);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -1564,13 +3534,15 @@ Java_com_redhat_et_libguestfs_GuestFS__1umount_1all
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1lvm_1remove_1all
-  (JNIEnv *env, jobject obj, jlong jg)
+Java_com_redhat_et_libguestfs_GuestFS__1drop_1caches
+  (JNIEnv *env, jobject obj, jlong jg, jint jwhattodrop)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
+  int whattodrop;
 
-  r = guestfs_lvm_remove_all (g);
+  whattodrop = jwhattodrop;
+  r = guestfs_drop_caches (g, whattodrop);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -1578,17 +3550,14 @@ Java_com_redhat_et_libguestfs_GuestFS__1lvm_1remove_1all
 }
 
 JNIEXPORT jstring JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1file
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+Java_com_redhat_et_libguestfs_GuestFS__1dmesg
+  (JNIEnv *env, jobject obj, jlong jg)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   jstring jr;
   char *r;
-  const char *path;
 
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_file (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  r = guestfs_dmesg (g);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
@@ -1598,42 +3567,44 @@ Java_com_redhat_et_libguestfs_GuestFS__1file
   return jr;
 }
 
-JNIEXPORT jstring JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1command
-  (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1ping_1daemon
+  (JNIEnv *env, jobject obj, jlong jg)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jstring jr;
-  char *r;
-  int arguments_len;
-  const char **arguments;
-  int i;
+  int r;
 
-  arguments_len = (*env)->GetArrayLength (env, jarguments);
-  arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
-  for (i = 0; i < arguments_len; ++i) {
-    jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
-    arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
-  }
-  arguments[arguments_len] = NULL;
-  r = guestfs_command (g, arguments);
-  for (i = 0; i < arguments_len; ++i) {
-    jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
-    (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
+  r = guestfs_ping_daemon (g);
+  if (r == -1) {
+    throw_exception (env, guestfs_last_error (g));
+    return ;
   }
-  free (arguments);
-  if (r == NULL) {
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1equal
+  (JNIEnv *env, jobject obj, jlong jg, jstring jfile1, jstring jfile2)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  int r;
+  const char *file1;
+  const char *file2;
+
+  file1 = (*env)->GetStringUTFChars (env, jfile1, NULL);
+  file2 = (*env)->GetStringUTFChars (env, jfile2, NULL);
+  r = guestfs_equal (g, file1, file2);
+  (*env)->ReleaseStringUTFChars (env, jfile1, file1);
+  (*env)->ReleaseStringUTFChars (env, jfile2, file2);
+  if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return NULL;
+    return 0;
   }
-  jr = (*env)->NewStringUTF (env, r);
-  free (r);
-  return jr;
+  return (jboolean) r;
 }
 
 JNIEXPORT jobjectArray JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1command_1lines
-  (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
+Java_com_redhat_et_libguestfs_GuestFS__1strings
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   jobjectArray jr;
@@ -1641,23 +3612,12 @@ Java_com_redhat_et_libguestfs_GuestFS__1command_1lines
   jclass cl;
   jstring jstr;
   char **r;
-  int arguments_len;
-  const char **arguments;
+  const char *path;
   int i;
 
-  arguments_len = (*env)->GetArrayLength (env, jarguments);
-  arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
-  for (i = 0; i < arguments_len; ++i) {
-    jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
-    arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
-  }
-  arguments[arguments_len] = NULL;
-  r = guestfs_command_lines (g, arguments);
-  for (i = 0; i < arguments_len; ++i) {
-    jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
-    (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
-  }
-  free (arguments);
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_strings (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
@@ -1675,173 +3635,82 @@ Java_com_redhat_et_libguestfs_GuestFS__1command_1lines
   return jr;
 }
 
-JNIEXPORT jobject JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1stat
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1strings_1e
+  (JNIEnv *env, jobject obj, jlong jg, jstring jencoding, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobject jr;
+  jobjectArray jr;
+  int r_len;
   jclass cl;
-  jfieldID fl;
-  struct guestfs_stat *r;
+  jstring jstr;
+  char **r;
+  const char *encoding;
   const char *path;
+  int i;
 
+  encoding = (*env)->GetStringUTFChars (env, jencoding, NULL);
   path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_stat (g, path);
+  r = guestfs_strings_e (g, encoding, path);
+  (*env)->ReleaseStringUTFChars (env, jencoding, encoding);
   (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
   }
-  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
-  jr = (*env)->AllocObject (env, cl);
-  fl = (*env)->GetFieldID (env, cl, "dev", "J");
-  (*env)->SetLongField (env, jr, fl, r->dev);
-  fl = (*env)->GetFieldID (env, cl, "ino", "J");
-  (*env)->SetLongField (env, jr, fl, r->ino);
-  fl = (*env)->GetFieldID (env, cl, "mode", "J");
-  (*env)->SetLongField (env, jr, fl, r->mode);
-  fl = (*env)->GetFieldID (env, cl, "nlink", "J");
-  (*env)->SetLongField (env, jr, fl, r->nlink);
-  fl = (*env)->GetFieldID (env, cl, "uid", "J");
-  (*env)->SetLongField (env, jr, fl, r->uid);
-  fl = (*env)->GetFieldID (env, cl, "gid", "J");
-  (*env)->SetLongField (env, jr, fl, r->gid);
-  fl = (*env)->GetFieldID (env, cl, "rdev", "J");
-  (*env)->SetLongField (env, jr, fl, r->rdev);
-  fl = (*env)->GetFieldID (env, cl, "size", "J");
-  (*env)->SetLongField (env, jr, fl, r->size);
-  fl = (*env)->GetFieldID (env, cl, "blksize", "J");
-  (*env)->SetLongField (env, jr, fl, r->blksize);
-  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
-  (*env)->SetLongField (env, jr, fl, r->blocks);
-  fl = (*env)->GetFieldID (env, cl, "atime", "J");
-  (*env)->SetLongField (env, jr, fl, r->atime);
-  fl = (*env)->GetFieldID (env, cl, "mtime", "J");
-  (*env)->SetLongField (env, jr, fl, r->mtime);
-  fl = (*env)->GetFieldID (env, cl, "ctime", "J");
-  (*env)->SetLongField (env, jr, fl, r->ctime);
-  free (r);
-  return jr;
-}
-
-JNIEXPORT jobject JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1lstat
-  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
-{
-  guestfs_h *g = (guestfs_h *) (long) jg;
-  jobject jr;
-  jclass cl;
-  jfieldID fl;
-  struct guestfs_stat *r;
-  const char *path;
-
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_lstat (g, path);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
-  if (r == NULL) {
-    throw_exception (env, guestfs_last_error (g));
-    return NULL;
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
   }
-  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
-  jr = (*env)->AllocObject (env, cl);
-  fl = (*env)->GetFieldID (env, cl, "dev", "J");
-  (*env)->SetLongField (env, jr, fl, r->dev);
-  fl = (*env)->GetFieldID (env, cl, "ino", "J");
-  (*env)->SetLongField (env, jr, fl, r->ino);
-  fl = (*env)->GetFieldID (env, cl, "mode", "J");
-  (*env)->SetLongField (env, jr, fl, r->mode);
-  fl = (*env)->GetFieldID (env, cl, "nlink", "J");
-  (*env)->SetLongField (env, jr, fl, r->nlink);
-  fl = (*env)->GetFieldID (env, cl, "uid", "J");
-  (*env)->SetLongField (env, jr, fl, r->uid);
-  fl = (*env)->GetFieldID (env, cl, "gid", "J");
-  (*env)->SetLongField (env, jr, fl, r->gid);
-  fl = (*env)->GetFieldID (env, cl, "rdev", "J");
-  (*env)->SetLongField (env, jr, fl, r->rdev);
-  fl = (*env)->GetFieldID (env, cl, "size", "J");
-  (*env)->SetLongField (env, jr, fl, r->size);
-  fl = (*env)->GetFieldID (env, cl, "blksize", "J");
-  (*env)->SetLongField (env, jr, fl, r->blksize);
-  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
-  (*env)->SetLongField (env, jr, fl, r->blocks);
-  fl = (*env)->GetFieldID (env, cl, "atime", "J");
-  (*env)->SetLongField (env, jr, fl, r->atime);
-  fl = (*env)->GetFieldID (env, cl, "mtime", "J");
-  (*env)->SetLongField (env, jr, fl, r->mtime);
-  fl = (*env)->GetFieldID (env, cl, "ctime", "J");
-  (*env)->SetLongField (env, jr, fl, r->ctime);
   free (r);
   return jr;
 }
 
-JNIEXPORT jobject JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1statvfs
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1hexdump
   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jobject jr;
-  jclass cl;
-  jfieldID fl;
-  struct guestfs_statvfs *r;
+  jstring jr;
+  char *r;
   const char *path;
 
   path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_statvfs (g, path);
+  r = guestfs_hexdump (g, path);
   (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
-  }
-  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
-  jr = (*env)->AllocObject (env, cl);
-  fl = (*env)->GetFieldID (env, cl, "bsize", "J");
-  (*env)->SetLongField (env, jr, fl, r->bsize);
-  fl = (*env)->GetFieldID (env, cl, "frsize", "J");
-  (*env)->SetLongField (env, jr, fl, r->frsize);
-  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
-  (*env)->SetLongField (env, jr, fl, r->blocks);
-  fl = (*env)->GetFieldID (env, cl, "bfree", "J");
-  (*env)->SetLongField (env, jr, fl, r->bfree);
-  fl = (*env)->GetFieldID (env, cl, "bavail", "J");
-  (*env)->SetLongField (env, jr, fl, r->bavail);
-  fl = (*env)->GetFieldID (env, cl, "files", "J");
-  (*env)->SetLongField (env, jr, fl, r->files);
-  fl = (*env)->GetFieldID (env, cl, "ffree", "J");
-  (*env)->SetLongField (env, jr, fl, r->ffree);
-  fl = (*env)->GetFieldID (env, cl, "favail", "J");
-  (*env)->SetLongField (env, jr, fl, r->favail);
-  fl = (*env)->GetFieldID (env, cl, "fsid", "J");
-  (*env)->SetLongField (env, jr, fl, r->fsid);
-  fl = (*env)->GetFieldID (env, cl, "flag", "J");
-  (*env)->SetLongField (env, jr, fl, r->flag);
-  fl = (*env)->GetFieldID (env, cl, "namemax", "J");
-  (*env)->SetLongField (env, jr, fl, r->namemax);
+  }
+  jr = (*env)->NewStringUTF (env, r);
   free (r);
   return jr;
 }
 
-JNIEXPORT jobject JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1tune2fs_1l
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1zerofree
   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  char **r;
+  int r;
   const char *device;
 
   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_tune2fs_l (g, device);
+  r = guestfs_zerofree (g, device);
   (*env)->ReleaseStringUTFChars (env, jdevice, device);
-  if (r == NULL) {
+  if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return NULL;
+    return ;
   }
-  throw_exception (env, "tune2fs_l: internal error: please let us know how to make a Java HashMap from JNI bindings!");
-  return NULL;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setro
+Java_com_redhat_et_libguestfs_GuestFS__1pvresize
   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
@@ -1849,7 +3718,7 @@ Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setro
   const char *device;
 
   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_blockdev_setro (g, device);
+  r = guestfs_pvresize (g, device);
   (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
@@ -1858,133 +3727,164 @@ Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setro
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setrw
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
+Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1N
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jpartnum, jint jcyls, jint jheads, jint jsectors, jstring jline)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
   const char *device;
+  int partnum;
+  int cyls;
+  int heads;
+  int sectors;
+  const char *line;
 
   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_blockdev_setrw (g, device);
+  partnum = jpartnum;
+  cyls = jcyls;
+  heads = jheads;
+  sectors = jsectors;
+  line = (*env)->GetStringUTFChars (env, jline, NULL);
+  r = guestfs_sfdisk_N (g, device, partnum, cyls, heads, sectors, line);
   (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  (*env)->ReleaseStringUTFChars (env, jline, line);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
   }
 }
 
-JNIEXPORT jboolean JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getro
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1l
   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
+  jstring jr;
+  char *r;
   const char *device;
 
   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_blockdev_getro (g, device);
+  r = guestfs_sfdisk_l (g, device);
   (*env)->ReleaseStringUTFChars (env, jdevice, device);
-  if (r == -1) {
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return 0;
+    return NULL;
   }
-  return (jboolean) r;
+  jr = (*env)->NewStringUTF (env, r);
+  free (r);
+  return jr;
 }
 
-JNIEXPORT jint JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getss
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1kernel_1geometry
   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
+  jstring jr;
+  char *r;
   const char *device;
 
   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_blockdev_getss (g, device);
+  r = guestfs_sfdisk_kernel_geometry (g, device);
   (*env)->ReleaseStringUTFChars (env, jdevice, device);
-  if (r == -1) {
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return 0;
+    return NULL;
   }
-  return (jint) r;
+  jr = (*env)->NewStringUTF (env, r);
+  free (r);
+  return jr;
 }
 
-JNIEXPORT jint JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getbsz
+JNIEXPORT jstring JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1disk_1geometry
   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
+  jstring jr;
+  char *r;
   const char *device;
 
   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_blockdev_getbsz (g, device);
+  r = guestfs_sfdisk_disk_geometry (g, device);
   (*env)->ReleaseStringUTFChars (env, jdevice, device);
-  if (r == -1) {
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return 0;
+    return NULL;
   }
-  return (jint) r;
+  jr = (*env)->NewStringUTF (env, r);
+  free (r);
+  return jr;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setbsz
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jblocksize)
+Java_com_redhat_et_libguestfs_GuestFS__1vg_1activate_1all
+  (JNIEnv *env, jobject obj, jlong jg, jboolean jactivate)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *device;
-  int blocksize;
+  int activate;
 
-  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  blocksize = jblocksize;
-  r = guestfs_blockdev_setbsz (g, device, blocksize);
-  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  activate = jactivate;
+  r = guestfs_vg_activate_all (g, activate);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
   }
 }
 
-JNIEXPORT jlong JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsz
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1vg_1activate
+  (JNIEnv *env, jobject obj, jlong jg, jboolean jactivate, jobjectArray jvolgroups)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int64_t r;
-  const char *device;
+  int r;
+  int activate;
+  int volgroups_len;
+  const char **volgroups;
+  int i;
 
-  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_blockdev_getsz (g, device);
-  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  activate = jactivate;
+  volgroups_len = (*env)->GetArrayLength (env, jvolgroups);
+  volgroups = guestfs_safe_malloc (g, sizeof (char *) * (volgroups_len+1));
+  for (i = 0; i < volgroups_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jvolgroups, i);
+    volgroups[i] = (*env)->GetStringUTFChars (env, o, NULL);
+  }
+  volgroups[volgroups_len] = NULL;
+  r = guestfs_vg_activate (g, activate, volgroups);
+  for (i = 0; i < volgroups_len; ++i) {
+    jobject o = (*env)->GetObjectArrayElement (env, jvolgroups, i);
+    (*env)->ReleaseStringUTFChars (env, o, volgroups[i]);
+  }
+  free (volgroups);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return 0;
+    return ;
   }
-  return (jlong) r;
 }
 
-JNIEXPORT jlong JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsize64
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1lvresize
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jmbytes)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int64_t r;
+  int r;
   const char *device;
+  int mbytes;
 
   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_blockdev_getsize64 (g, device);
+  mbytes = jmbytes;
+  r = guestfs_lvresize (g, device, mbytes);
   (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return 0;
+    return ;
   }
-  return (jlong) r;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1flushbufs
+Java_com_redhat_et_libguestfs_GuestFS__1resize2fs
   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
@@ -1992,7 +3892,7 @@ Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1flushbufs
   const char *device;
 
   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_blockdev_flushbufs (g, device);
+  r = guestfs_resize2fs (g, device);
   (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
@@ -2000,8 +3900,41 @@ Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1flushbufs
   }
 }
 
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1find
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  const char *directory;
+  int i;
+
+  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
+  r = guestfs_find (g, directory);
+  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
+  if (r == NULL) {
+    throw_exception (env, guestfs_last_error (g));
+    return NULL;
+  }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
+  free (r);
+  return jr;
+}
+
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1rereadpt
+Java_com_redhat_et_libguestfs_GuestFS__1e2fsck_1f
   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
@@ -2009,7 +3942,7 @@ Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1rereadpt
   const char *device;
 
   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_blockdev_rereadpt (g, device);
+  r = guestfs_e2fsck_f (g, device);
   (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
@@ -2018,60 +3951,53 @@ Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1rereadpt
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1upload
-  (JNIEnv *env, jobject obj, jlong jg, jstring jfilename, jstring jremotefilename)
+Java_com_redhat_et_libguestfs_GuestFS__1sleep
+  (JNIEnv *env, jobject obj, jlong jg, jint jsecs)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *filename;
-  const char *remotefilename;
+  int secs;
 
-  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
-  remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
-  r = guestfs_upload (g, filename, remotefilename);
-  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
-  (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
+  secs = jsecs;
+  r = guestfs_sleep (g, secs);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
   }
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1download
-  (JNIEnv *env, jobject obj, jlong jg, jstring jremotefilename, jstring jfilename)
+JNIEXPORT jint JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1ntfs_13g_1probe
+  (JNIEnv *env, jobject obj, jlong jg, jboolean jrw, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *remotefilename;
-  const char *filename;
+  int rw;
+  const char *device;
 
-  remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
-  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
-  r = guestfs_download (g, remotefilename, filename);
-  (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
-  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
+  rw = jrw;
+  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
+  r = guestfs_ntfs_3g_probe (g, rw, device);
+  (*env)->ReleaseStringUTFChars (env, jdevice, device);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return 0;
   }
+  return (jint) r;
 }
 
 JNIEXPORT jstring JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1checksum
-  (JNIEnv *env, jobject obj, jlong jg, jstring jcsumtype, jstring jpath)
+Java_com_redhat_et_libguestfs_GuestFS__1sh
+  (JNIEnv *env, jobject obj, jlong jg, jstring jcommand)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   jstring jr;
   char *r;
-  const char *csumtype;
-  const char *path;
+  const char *command;
 
-  csumtype = (*env)->GetStringUTFChars (env, jcsumtype, NULL);
-  path = (*env)->GetStringUTFChars (env, jpath, NULL);
-  r = guestfs_checksum (g, csumtype, path);
-  (*env)->ReleaseStringUTFChars (env, jcsumtype, csumtype);
-  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  command = (*env)->GetStringUTFChars (env, jcommand, NULL);
+  r = guestfs_sh (g, command);
+  (*env)->ReleaseStringUTFChars (env, jcommand, command);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
@@ -2081,100 +4007,83 @@ Java_com_redhat_et_libguestfs_GuestFS__1checksum
   return jr;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1tar_1in
-  (JNIEnv *env, jobject obj, jlong jg, jstring jtarfile, jstring jdirectory)
-{
-  guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  const char *tarfile;
-  const char *directory;
-
-  tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
-  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
-  r = guestfs_tar_in (g, tarfile, directory);
-  (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
-  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
-  if (r == -1) {
-    throw_exception (env, guestfs_last_error (g));
-    return ;
-  }
-}
-
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1tar_1out
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarfile)
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1sh_1lines
+  (JNIEnv *env, jobject obj, jlong jg, jstring jcommand)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  const char *directory;
-  const char *tarfile;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  const char *command;
+  int i;
 
-  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
-  tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
-  r = guestfs_tar_out (g, directory, tarfile);
-  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
-  (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
-  if (r == -1) {
+  command = (*env)->GetStringUTFChars (env, jcommand, NULL);
+  r = guestfs_sh_lines (g, command);
+  (*env)->ReleaseStringUTFChars (env, jcommand, command);
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return NULL;
   }
-}
-
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1tgz_1in
-  (JNIEnv *env, jobject obj, jlong jg, jstring jtarball, jstring jdirectory)
-{
-  guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  const char *tarball;
-  const char *directory;
-
-  tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
-  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
-  r = guestfs_tgz_in (g, tarball, directory);
-  (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
-  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
-  if (r == -1) {
-    throw_exception (env, guestfs_last_error (g));
-    return ;
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
   }
+  free (r);
+  return jr;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1tgz_1out
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarball)
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1glob_1expand
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpattern)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  const char *directory;
-  const char *tarball;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  const char *pattern;
+  int i;
 
-  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
-  tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
-  r = guestfs_tgz_out (g, directory, tarball);
-  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
-  (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
-  if (r == -1) {
+  pattern = (*env)->GetStringUTFChars (env, jpattern, NULL);
+  r = guestfs_glob_expand (g, pattern);
+  (*env)->ReleaseStringUTFChars (env, jpattern, pattern);
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return NULL;
+  }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
   }
+  free (r);
+  return jr;
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1mount_1ro
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
+Java_com_redhat_et_libguestfs_GuestFS__1scrub_1device
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
   const char *device;
-  const char *mountpoint;
 
   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
-  r = guestfs_mount_ro (g, device, mountpoint);
+  r = guestfs_scrub_device (g, device);
   (*env)->ReleaseStringUTFChars (env, jdevice, device);
-  (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -2182,22 +4091,16 @@ Java_com_redhat_et_libguestfs_GuestFS__1mount_1ro
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1mount_1options
-  (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jdevice, jstring jmountpoint)
+Java_com_redhat_et_libguestfs_GuestFS__1scrub_1file
+  (JNIEnv *env, jobject obj, jlong jg, jstring jfile)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *options;
-  const char *device;
-  const char *mountpoint;
+  const char *file;
 
-  options = (*env)->GetStringUTFChars (env, joptions, NULL);
-  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
-  r = guestfs_mount_options (g, options, device, mountpoint);
-  (*env)->ReleaseStringUTFChars (env, joptions, options);
-  (*env)->ReleaseStringUTFChars (env, jdevice, device);
-  (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
+  file = (*env)->GetStringUTFChars (env, jfile, NULL);
+  r = guestfs_scrub_file (g, file);
+  (*env)->ReleaseStringUTFChars (env, jfile, file);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -2205,25 +4108,16 @@ Java_com_redhat_et_libguestfs_GuestFS__1mount_1options
 }
 
 JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1mount_1vfs
-  (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jvfstype, jstring jdevice, jstring jmountpoint)
+Java_com_redhat_et_libguestfs_GuestFS__1scrub_1freespace
+  (JNIEnv *env, jobject obj, jlong jg, jstring jdir)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *options;
-  const char *vfstype;
-  const char *device;
-  const char *mountpoint;
+  const char *dir;
 
-  options = (*env)->GetStringUTFChars (env, joptions, NULL);
-  vfstype = (*env)->GetStringUTFChars (env, jvfstype, NULL);
-  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
-  r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
-  (*env)->ReleaseStringUTFChars (env, joptions, options);
-  (*env)->ReleaseStringUTFChars (env, jvfstype, vfstype);
-  (*env)->ReleaseStringUTFChars (env, jdevice, device);
-  (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
+  dir = (*env)->GetStringUTFChars (env, jdir, NULL);
+  r = guestfs_scrub_freespace (g, dir);
+  (*env)->ReleaseStringUTFChars (env, jdir, dir);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
     return ;
@@ -2231,32 +4125,17 @@ Java_com_redhat_et_libguestfs_GuestFS__1mount_1vfs
 }
 
 JNIEXPORT jstring JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1debug
-  (JNIEnv *env, jobject obj, jlong jg, jstring jsubcmd, jobjectArray jextraargs)
+Java_com_redhat_et_libguestfs_GuestFS__1mkdtemp
+  (JNIEnv *env, jobject obj, jlong jg, jstring jtemplate)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   jstring jr;
   char *r;
-  const char *subcmd;
-  int extraargs_len;
-  const char **extraargs;
-  int i;
+  const char *template;
 
-  subcmd = (*env)->GetStringUTFChars (env, jsubcmd, NULL);
-  extraargs_len = (*env)->GetArrayLength (env, jextraargs);
-  extraargs = guestfs_safe_malloc (g, sizeof (char *) * (extraargs_len+1));
-  for (i = 0; i < extraargs_len; ++i) {
-    jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
-    extraargs[i] = (*env)->GetStringUTFChars (env, o, NULL);
-  }
-  extraargs[extraargs_len] = NULL;
-  r = guestfs_debug (g, subcmd, extraargs);
-  (*env)->ReleaseStringUTFChars (env, jsubcmd, subcmd);
-  for (i = 0; i < extraargs_len; ++i) {
-    jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
-    (*env)->ReleaseStringUTFChars (env, o, extraargs[i]);
-  }
-  free (extraargs);
+  template = (*env)->GetStringUTFChars (env, jtemplate, NULL);
+  r = guestfs_mkdtemp (g, template);
+  (*env)->ReleaseStringUTFChars (env, jtemplate, template);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
@@ -2266,135 +4145,192 @@ Java_com_redhat_et_libguestfs_GuestFS__1debug
   return jr;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1lvremove
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
+JNIEXPORT jint JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1wc_1l
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *device;
+  const char *path;
 
-  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_lvremove (g, device);
-  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_wc_l (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return 0;
   }
+  return (jint) r;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1vgremove
-  (JNIEnv *env, jobject obj, jlong jg, jstring jvgname)
+JNIEXPORT jint JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1wc_1w
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *vgname;
+  const char *path;
 
-  vgname = (*env)->GetStringUTFChars (env, jvgname, NULL);
-  r = guestfs_vgremove (g, vgname);
-  (*env)->ReleaseStringUTFChars (env, jvgname, vgname);
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_wc_w (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return 0;
   }
+  return (jint) r;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1pvremove
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
+JNIEXPORT jint JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1wc_1c
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
   int r;
-  const char *device;
+  const char *path;
 
-  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_pvremove (g, device);
-  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_wc_c (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == -1) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return 0;
   }
+  return (jint) r;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1set_1e2label
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jlabel)
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1head
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  const char *device;
-  const char *label;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  const char *path;
+  int i;
 
-  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  label = (*env)->GetStringUTFChars (env, jlabel, NULL);
-  r = guestfs_set_e2label (g, device, label);
-  (*env)->ReleaseStringUTFChars (env, jdevice, device);
-  (*env)->ReleaseStringUTFChars (env, jlabel, label);
-  if (r == -1) {
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_head (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return NULL;
+  }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
   }
+  free (r);
+  return jr;
 }
 
-JNIEXPORT jstring JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1get_1e2label
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1head_1n
+  (JNIEnv *env, jobject obj, jlong jg, jint jnrlines, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jstring jr;
-  char *r;
-  const char *device;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  int nrlines;
+  const char *path;
+  int i;
 
-  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_get_e2label (g, device);
-  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  nrlines = jnrlines;
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_head_n (g, nrlines, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
   }
-  jr = (*env)->NewStringUTF (env, r);
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
   free (r);
   return jr;
 }
 
-JNIEXPORT void JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1set_1e2uuid
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring juuid)
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1tail
+  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  int r;
-  const char *device;
-  const char *uuid;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  const char *path;
+  int i;
 
-  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  uuid = (*env)->GetStringUTFChars (env, juuid, NULL);
-  r = guestfs_set_e2uuid (g, device, uuid);
-  (*env)->ReleaseStringUTFChars (env, jdevice, device);
-  (*env)->ReleaseStringUTFChars (env, juuid, uuid);
-  if (r == -1) {
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_tail (g, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
+  if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
-    return ;
+    return NULL;
+  }
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
   }
+  free (r);
+  return jr;
 }
 
-JNIEXPORT jstring JNICALL
-Java_com_redhat_et_libguestfs_GuestFS__1get_1e2uuid
-  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
+JNIEXPORT jobjectArray JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1tail_1n
+  (JNIEnv *env, jobject obj, jlong jg, jint jnrlines, jstring jpath)
 {
   guestfs_h *g = (guestfs_h *) (long) jg;
-  jstring jr;
-  char *r;
-  const char *device;
+  jobjectArray jr;
+  int r_len;
+  jclass cl;
+  jstring jstr;
+  char **r;
+  int nrlines;
+  const char *path;
+  int i;
 
-  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
-  r = guestfs_get_e2uuid (g, device);
-  (*env)->ReleaseStringUTFChars (env, jdevice, device);
+  nrlines = jnrlines;
+  path = (*env)->GetStringUTFChars (env, jpath, NULL);
+  r = guestfs_tail_n (g, nrlines, path);
+  (*env)->ReleaseStringUTFChars (env, jpath, path);
   if (r == NULL) {
     throw_exception (env, guestfs_last_error (g));
     return NULL;
   }
-  jr = (*env)->NewStringUTF (env, r);
+  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
+  cl = (*env)->FindClass (env, "java/lang/String");
+  jstr = (*env)->NewStringUTF (env, "");
+  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
+  for (i = 0; i < r_len; ++i) {
+    jstr = (*env)->NewStringUTF (env, r[i]);
+    (*env)->SetObjectArrayElement (env, jr, i, jstr);
+    free (r[i]);
+  }
   free (r);
   return jr;
 }