sys/rump/librump/rumpvfs/rumpvfs_if_wrappers.c

   1 /*      $NetBSD: makerumpif.sh,v 1.4 2009/10/15 00:29:19 pooka Exp $    */
   2
   3 /*
   4  * Automatically generated.  DO NOT EDIT.
   5  * from: NetBSD: rumpvfs.ifspec,v 1.1 2009/10/14 17:17:00 pooka Exp
   6  * by:   NetBSD: makerumpif.sh,v 1.4 2009/10/15 00:29:19 pooka Exp
   7  */
   8
   9 #include <sys/cdefs.h>
  10 #include <sys/systm.h>
  11
  12 #include <rump/rump.h>
  13 #include <rump/rumpvfs_if_pub.h>
  14
  15 #include "rump_private.h"
  16 #include "rumpvfs_if_priv.h"
  17
  18 void __dead rump_vfs_unavailable(void);
  19 void __dead
  20 rump_vfs_unavailable(void)
  21 {
  22
  23         panic("vfs interface unavailable");
  24 }
  25
  26 void
  27 rump_pub_getvninfo(struct vnode *arg1, enum vtype *arg2, off_t *arg3, dev_t *arg4)
  28 {
  29
  30         rump_schedule();
  31         rump_getvninfo(arg1, arg2, arg3, arg4);
  32         rump_unschedule();
  33 }
  34
  35 struct vfsops *
  36 rump_pub_vfslist_iterate(struct vfsops *arg1)
  37 {
  38         struct vfsops * rv;
  39
  40         rump_schedule();
  41         rv = rump_vfslist_iterate(arg1);
  42         rump_unschedule();
  43
  44         return rv;
  45 }
  46
  47 struct vfsops *
  48 rump_pub_vfs_getopsbyname(const char *arg1)
  49 {
  50         struct vfsops * rv;
  51
  52         rump_schedule();
  53         rv = rump_vfs_getopsbyname(arg1);
  54         rump_unschedule();
  55
  56         return rv;
  57 }
  58
  59 struct vattr *
  60 rump_pub_vattr_init(void)
  61 {
  62         struct vattr * rv;
  63
  64         rump_schedule();
  65         rv = rump_vattr_init();
  66         rump_unschedule();
  67
  68         return rv;
  69 }
  70
  71 void
  72 rump_pub_vattr_settype(struct vattr *arg1, enum vtype arg2)
  73 {
  74
  75         rump_schedule();
  76         rump_vattr_settype(arg1, arg2);
  77         rump_unschedule();
  78 }
  79
  80 void
  81 rump_pub_vattr_setmode(struct vattr *arg1, mode_t arg2)
  82 {
  83
  84         rump_schedule();
  85         rump_vattr_setmode(arg1, arg2);
  86         rump_unschedule();
  87 }
  88
  89 void
  90 rump_pub_vattr_setrdev(struct vattr *arg1, dev_t arg2)
  91 {
  92
  93         rump_schedule();
  94         rump_vattr_setrdev(arg1, arg2);
  95         rump_unschedule();
  96 }
  97
  98 void
  99 rump_pub_vattr_free(struct vattr *arg1)
 100 {
 101
 102         rump_schedule();
 103         rump_vattr_free(arg1);
 104         rump_unschedule();
 105 }
 106
 107 void
 108 rump_pub_vp_incref(struct vnode *arg1)
 109 {
 110
 111         rump_schedule();
 112         rump_vp_incref(arg1);
 113         rump_unschedule();
 114 }
 115
 116 int
 117 rump_pub_vp_getref(struct vnode *arg1)
 118 {
 119         int rv;
 120
 121         rump_schedule();
 122         rv = rump_vp_getref(arg1);
 123         rump_unschedule();
 124
 125         return rv;
 126 }
 127
 128 void
 129 rump_pub_vp_rele(struct vnode *arg1)
 130 {
 131
 132         rump_schedule();
 133         rump_vp_rele(arg1);
 134         rump_unschedule();
 135 }
 136
 137 void
 138 rump_pub_vp_interlock(struct vnode *arg1)
 139 {
 140
 141         rump_schedule();
 142         rump_vp_interlock(arg1);
 143         rump_unschedule();
 144 }
 145
 146 int
 147 rump_pub_etfs_register(const char *arg1, const char *arg2, enum rump_etfs_type arg3)
 148 {
 149         int rv;
 150
 151         rump_schedule();
 152         rv = rump_etfs_register(arg1, arg2, arg3);
 153         rump_unschedule();
 154
 155         return rv;
 156 }
 157
 158 int
 159 rump_pub_etfs_register_withsize(const char *arg1, const char *arg2, enum rump_etfs_type arg3, uint64_t arg4, uint64_t arg5)
 160 {
 161         int rv;
 162
 163         rump_schedule();
 164         rv = rump_etfs_register_withsize(arg1, arg2, arg3, arg4, arg5);
 165         rump_unschedule();
 166
 167         return rv;
 168 }
 169
 170 int
 171 rump_pub_etfs_remove(const char *arg1)
 172 {
 173         int rv;
 174
 175         rump_schedule();
 176         rv = rump_etfs_remove(arg1);
 177         rump_unschedule();
 178
 179         return rv;
 180 }
 181
 182 void
 183 rump_pub_freecn(struct componentname *arg1, int arg2)
 184 {
 185
 186         rump_schedule();
 187         rump_freecn(arg1, arg2);
 188         rump_unschedule();
 189 }
 190
 191 int
 192 rump_pub_checksavecn(struct componentname *arg1)
 193 {
 194         int rv;
 195
 196         rump_schedule();
 197         rv = rump_checksavecn(arg1);
 198         rump_unschedule();
 199
 200         return rv;
 201 }
 202
 203 int
 204 rump_pub_namei(uint32_t arg1, uint32_t arg2, const char *arg3, struct vnode **arg4, struct vnode **arg5, struct componentname **arg6)
 205 {
 206         int rv;
 207
 208         rump_schedule();
 209         rv = rump_namei(arg1, arg2, arg3, arg4, arg5, arg6);
 210         rump_unschedule();
 211
 212         return rv;
 213 }
 214
 215 struct componentname *
 216 rump_pub_makecn(u_long arg1, u_long arg2, const char *arg3, size_t arg4, kauth_cred_t arg5, struct lwp *arg6)
 217 {
 218         struct componentname * rv;
 219
 220         rump_schedule();
 221         rv = rump_makecn(arg1, arg2, arg3, arg4, arg5, arg6);
 222         rump_unschedule();
 223
 224         return rv;
 225 }
 226
 227 int
 228 rump_pub_vfs_unmount(struct mount *arg1, int arg2)
 229 {
 230         int rv;
 231
 232         rump_schedule();
 233         rv = rump_vfs_unmount(arg1, arg2);
 234         rump_unschedule();
 235
 236         return rv;
 237 }
 238
 239 int
 240 rump_pub_vfs_root(struct mount *arg1, struct vnode **arg2, int arg3)
 241 {
 242         int rv;
 243
 244         rump_schedule();
 245         rv = rump_vfs_root(arg1, arg2, arg3);
 246         rump_unschedule();
 247
 248         return rv;
 249 }
 250
 251 int
 252 rump_pub_vfs_statvfs(struct mount *arg1, struct statvfs *arg2)
 253 {
 254         int rv;
 255
 256         rump_schedule();
 257         rv = rump_vfs_statvfs(arg1, arg2);
 258         rump_unschedule();
 259
 260         return rv;
 261 }
 262
 263 int
 264 rump_pub_vfs_sync(struct mount *arg1, int arg2, kauth_cred_t arg3)
 265 {
 266         int rv;
 267
 268         rump_schedule();
 269         rv = rump_vfs_sync(arg1, arg2, arg3);
 270         rump_unschedule();
 271
 272         return rv;
 273 }
 274
 275 int
 276 rump_pub_vfs_fhtovp(struct mount *arg1, struct fid *arg2, struct vnode **arg3)
 277 {
 278         int rv;
 279
 280         rump_schedule();
 281         rv = rump_vfs_fhtovp(arg1, arg2, arg3);
 282         rump_unschedule();
 283
 284         return rv;
 285 }
 286
 287 int
 288 rump_pub_vfs_vptofh(struct vnode *arg1, struct fid *arg2, size_t *arg3)
 289 {
 290         int rv;
 291
 292         rump_schedule();
 293         rv = rump_vfs_vptofh(arg1, arg2, arg3);
 294         rump_unschedule();
 295
 296         return rv;
 297 }
 298
 299 void
 300 rump_pub_vfs_syncwait(struct mount *arg1)
 301 {
 302
 303         rump_schedule();
 304         rump_vfs_syncwait(arg1);
 305         rump_unschedule();
 306 }
 307
 308 int
 309 rump_pub_vfs_getmp(const char *arg1, struct mount **arg2)
 310 {
 311         int rv;
 312
 313         rump_schedule();
 314         rv = rump_vfs_getmp(arg1, arg2);
 315         rump_unschedule();
 316
 317         return rv;
 318 }
 319
 320 void
 321 rump_pub_rcvp_set(struct vnode *arg1, struct vnode *arg2)
 322 {
 323
 324         rump_schedule();
 325         rump_rcvp_set(arg1, arg2);
 326         rump_unschedule();
 327 }
 328
 329 struct vnode *
 330 rump_pub_cdir_get(void)
 331 {
 332         struct vnode * rv;
 333
 334         rump_schedule();
 335         rv = rump_cdir_get();
 336         rump_unschedule();
 337
 338         return rv;
 339 }
 340
 341 int
 342 rump_pub_syspuffs_glueinit(int arg1, int *arg2)
 343 {
 344         int rv;
 345
 346         rump_schedule();
 347         rv = rump_syspuffs_glueinit(arg1, arg2);
 348         rump_unschedule();
 349
 350         return rv;
 351 }
 352 __weak_alias(rump_syspuffs_glueinit,rump_vfs_unavailable);
 353
 354 int
 355 rump_pub_sys___stat30(const char *arg1, struct stat *arg2)
 356 {
 357         int rv;
 358
 359         rump_schedule();
 360         rv = rump_sys___stat30(arg1, arg2);
 361         rump_unschedule();
 362
 363         return rv;
 364 }
 365
 366 int
 367 rump_pub_sys___lstat30(const char *arg1, struct stat *arg2)
 368 {
 369         int rv;
 370
 371         rump_schedule();
 372         rv = rump_sys___lstat30(arg1, arg2);
 373         rump_unschedule();
 374
 375         return rv;
 376 }
 377
 378 void
 379 rump_pub_vattr50_to_vattr(const struct vattr *arg1, struct vattr *arg2)
 380 {
 381
 382         rump_schedule();
 383         rump_vattr50_to_vattr(arg1, arg2);
 384         rump_unschedule();
 385 }
 386
 387 void
 388 rump_pub_vattr_to_vattr50(const struct vattr *arg1, struct vattr *arg2)
 389 {
 390
 391         rump_schedule();
 392         rump_vattr_to_vattr50(arg1, arg2);
 393         rump_unschedule();
 394 }