95     struct fuse_fs* fs;  in __fuse_fs_new()  local
97     fs = malloc(sizeof(struct fuse_fs));  in __fuse_fs_new()
98     if (!fs)  in __fuse_fs_new()
104     fs->op = clone_op(op, op_version);  in __fuse_fs_new()
105     if (!fs->op)  in __fuse_fs_new()
108     fs->op_version = op_version;  in __fuse_fs_new()
109     fs->user_data  = user_data;  in __fuse_fs_new()
111     return fs;  in __fuse_fs_new()
118 clobber_context_user_data(struct fuse_fs* fs) {  in clobber_context_user_data()  argument
119     fuse_get_context()->private_data = fs->user_data;  in clobber_context_user_data()
124 fuse_fs_getattr_v27(struct fuse_fs *fs, const char *path, struct stat *buf) {  in fuse_fs_getattr_v27()  argument
125     return fuse_fs_getattr_v30(fs, path, buf, NULL);  in fuse_fs_getattr_v27()
129 fuse_fs_getattr_v30(struct fuse_fs* fs, const char* path,  in fuse_fs_getattr_v30()  argument
131     clobber_context_user_data(fs);  in fuse_fs_getattr_v30()
132     switch (fs->op_version) {  in fuse_fs_getattr_v30()
135         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getattr) \  in fuse_fs_getattr_v30()
136             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getattr(path, buf); \  in fuse_fs_getattr_v30()
151         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getattr) \  in fuse_fs_getattr_v30()
152 …          return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getattr(path, buf, fi); \  in fuse_fs_getattr_v30()
161         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_getattr_v30()
166 fuse_fs_fgetattr(struct fuse_fs* fs, const char* path, struct stat* buf,  in fuse_fs_fgetattr()  argument
168     clobber_context_user_data(fs);  in fuse_fs_fgetattr()
171     switch (fs->op_version) {  in fuse_fs_fgetattr()
176         return fuse_fs_getattr_v30(fs, path, buf, fi);  in fuse_fs_fgetattr()
180         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fgetattr) \  in fuse_fs_fgetattr()
181 …         return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fgetattr(path, buf, fi); \  in fuse_fs_fgetattr()
182         else if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getattr) \  in fuse_fs_fgetattr()
183             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getattr(path, buf); \  in fuse_fs_fgetattr()
196         return fuse_fs_getattr_v30(fs, path, buf, fi);  in fuse_fs_fgetattr()
198         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_fgetattr()
203 fuse_fs_rename_v27(struct fuse_fs* fs, const char* oldpath, const char* newpath) {  in fuse_fs_rename_v27()  argument
204     return fuse_fs_rename_v30(fs, oldpath, newpath, 0);  in fuse_fs_rename_v27()
208 fuse_fs_rename_v30(struct fuse_fs* fs, const char* oldpath,  in fuse_fs_rename_v30()  argument
210     clobber_context_user_data(fs);  in fuse_fs_rename_v30()
211     switch (fs->op_version) {  in fuse_fs_rename_v30()
214         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->rename) \  in fuse_fs_rename_v30()
215 …        return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->rename(oldpath, newpath); \  in fuse_fs_rename_v30()
230         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->rename) \  in fuse_fs_rename_v30()
231 … return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->rename(oldpath, newpath, flags); \  in fuse_fs_rename_v30()
240         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_rename_v30()
245 fuse_fs_unlink(struct fuse_fs* fs, const char* path) {  in fuse_fs_unlink()  argument
246     clobber_context_user_data(fs);  in fuse_fs_unlink()
247     switch (fs->op_version) {  in fuse_fs_unlink()
250         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->unlink) \  in fuse_fs_unlink()
251             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->unlink(path); \  in fuse_fs_unlink()
268         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_unlink()
273 fuse_fs_rmdir(struct fuse_fs* fs, const char* path) {  in fuse_fs_rmdir()  argument
274     clobber_context_user_data(fs);  in fuse_fs_rmdir()
275     switch (fs->op_version) {  in fuse_fs_rmdir()
278         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->rmdir) \  in fuse_fs_rmdir()
279             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->rmdir(path); \  in fuse_fs_rmdir()
296         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_rmdir()
301 fuse_fs_symlink(struct fuse_fs* fs, const char* linkname, const char* path) {  in fuse_fs_symlink()  argument
302     clobber_context_user_data(fs);  in fuse_fs_symlink()
303     switch (fs->op_version) {  in fuse_fs_symlink()
306         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->symlink) \  in fuse_fs_symlink()
307 …         return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->symlink(linkname, path); \  in fuse_fs_symlink()
324         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_symlink()
329 fuse_fs_link(struct fuse_fs* fs, const char* oldpath, const char* newpath) {  in fuse_fs_link()  argument
330     clobber_context_user_data(fs);  in fuse_fs_link()
331     switch (fs->op_version) {  in fuse_fs_link()
334         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->link) \  in fuse_fs_link()
335 …          return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->link(oldpath, newpath); \  in fuse_fs_link()
352         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_link()
357 fuse_fs_release(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi) {  in fuse_fs_release()  argument
358     clobber_context_user_data(fs);  in fuse_fs_release()
359     switch (fs->op_version) {  in fuse_fs_release()
362         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->release) \  in fuse_fs_release()
363 …        return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->release(path, fi->flags); \  in fuse_fs_release()
372         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->release) \  in fuse_fs_release()
373             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->release(path, fi); \  in fuse_fs_release()
388         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_release()
393 fuse_fs_open(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi) {  in fuse_fs_open()  argument
394     clobber_context_user_data(fs);  in fuse_fs_open()
395     switch (fs->op_version) {  in fuse_fs_open()
398         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->open) \  in fuse_fs_open()
399             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->open(path, fi->flags); \  in fuse_fs_open()
408         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->open) \  in fuse_fs_open()
409             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->open(path, fi); \  in fuse_fs_open()
424         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_open()
429 fuse_fs_read(struct fuse_fs* fs, const char* path, char* buf,  in fuse_fs_read()  argument
431     clobber_context_user_data(fs);  in fuse_fs_read()
432     switch (fs->op_version) {  in fuse_fs_read()
435         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->read) \  in fuse_fs_read()
436 …      return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->read(path, buf, size, off); \  in fuse_fs_read()
445         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->read) \  in fuse_fs_read()
446 …  return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->read(path, buf, size, off, fi); \  in fuse_fs_read()
461         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_read()
466 fuse_fs_read_buf(struct fuse_fs* fs, const char* path,  in fuse_fs_read_buf()  argument
469     clobber_context_user_data(fs);  in fuse_fs_read_buf()
470     switch (fs->op_version) {  in fuse_fs_read_buf()
482         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->read_buf) \  in fuse_fs_read_buf()
483 …return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->read_buf(path, bufp, size, off, fi…  in fuse_fs_read_buf()
493         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_read_buf()
498 fuse_fs_write(struct fuse_fs* fs, const char* path, const char* buf,  in fuse_fs_write()  argument
500     clobber_context_user_data(fs);  in fuse_fs_write()
501     switch (fs->op_version) {  in fuse_fs_write()
504         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->write) \  in fuse_fs_write()
505 …     return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->write(path, buf, size, off); \  in fuse_fs_write()
514         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->write) \  in fuse_fs_write()
515 … return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->write(path, buf, size, off, fi); \  in fuse_fs_write()
530         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_write()
535 fuse_fs_write_buf(struct fuse_fs* fs, const char* path,  in fuse_fs_write_buf()  argument
538     clobber_context_user_data(fs);  in fuse_fs_write_buf()
539     switch (fs->op_version) {  in fuse_fs_write_buf()
551         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->write_buf) \  in fuse_fs_write_buf()
552 …  return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->write_buf(path, bufp, off, fi); \  in fuse_fs_write_buf()
562         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_write_buf()
567 fuse_fs_fsync(struct fuse_fs* fs, const char* path, int datasync, struct fuse_file_info* fi) {  in fuse_fs_fsync()  argument
568     clobber_context_user_data(fs);  in fuse_fs_fsync()
569     switch (fs->op_version) {  in fuse_fs_fsync()
572         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fsync) \  in fuse_fs_fsync()
573             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fsync(path, datasync); \  in fuse_fs_fsync()
582         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fsync) \  in fuse_fs_fsync()
583 …       return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fsync(path, datasync, fi); \  in fuse_fs_fsync()
598         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_fsync()
603 fuse_fs_flush(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi) {  in fuse_fs_flush()  argument
604     clobber_context_user_data(fs);  in fuse_fs_flush()
607     switch (fs->op_version) {  in fuse_fs_flush()
611         if (((const struct fuse_operations_v21 *)fs->op)->flush)  in fuse_fs_flush()
612             return ((const struct fuse_operations_v21 *)fs->op)->flush(path);  in fuse_fs_flush()
618         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->flush) \  in fuse_fs_flush()
619             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->flush(path, fi); \  in fuse_fs_flush()
634         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_flush()
670 fuse_fs_statfs(struct fuse_fs* fs, const char* path, struct statvfs* buf) {  in fuse_fs_statfs()  argument
671     clobber_context_user_data(fs);  in fuse_fs_statfs()
675     switch (fs->op_version) {  in fuse_fs_statfs()
678         if (((const struct fuse_operations_v11*)fs->op)->statfs) {  in fuse_fs_statfs()
682             ret = ((const struct fuse_operations_v11*)fs->op)->statfs(path, &statfs_v11);  in fuse_fs_statfs()
695         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->statfs) { \  in fuse_fs_statfs()
699 …        ret = ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->statfs(path, &statfs_v22); \  in fuse_fs_statfs()
714         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->statfs) \  in fuse_fs_statfs()
715             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->statfs(path, buf); \  in fuse_fs_statfs()
728         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_statfs()
733 fuse_fs_opendir(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi) {  in fuse_fs_opendir()  argument
734     clobber_context_user_data(fs);  in fuse_fs_opendir()
735     switch (fs->op_version) {  in fuse_fs_opendir()
745         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->opendir) \  in fuse_fs_opendir()
746             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->opendir(path, fi); \  in fuse_fs_opendir()
760         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_opendir()
841 fuse_fs_readdir_v27(struct fuse_fs* fs, const char* path, void* buf,  in fuse_fs_readdir_v27()  argument
850     clobber_context_user_data(fs);  in fuse_fs_readdir_v27()
852     switch (fs->op_version) {  in fuse_fs_readdir_v27()
856         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getdir) \  in fuse_fs_readdir_v27()
857 …return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getdir(path, &v23_shim, fuse_dirfi…  in fuse_fs_readdir_v27()
867         if (((const struct fuse_operations_v22*)fs->op)->getdir)  in fuse_fs_readdir_v27()
868 …return ((const struct fuse_operations_v22*)fs->op)->getdir(path, &v23_shim, fuse_dirfil_v22_to_fil…  in fuse_fs_readdir_v27()
878         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->readdir) \  in fuse_fs_readdir_v27()
879 …return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->readdir(path, buf, filler, off, fi…  in fuse_fs_readdir_v27()
880         else if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getdir) \  in fuse_fs_readdir_v27()
881 …return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getdir(path, &v23_shim, fuse_dirfi…  in fuse_fs_readdir_v27()
894         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_readdir_v27()
899 fuse_fs_readdir_v30(struct fuse_fs* fs, const char* path, void* buf,  in fuse_fs_readdir_v30()  argument
902     clobber_context_user_data(fs);  in fuse_fs_readdir_v30()
904     if (fs->op_version < 30) {  in fuse_fs_readdir_v30()
910         return fuse_fs_readdir_v27(fs, path, &v30_shim, fuse_fill_dir_v23_to_v30, off, fi);  in fuse_fs_readdir_v30()
913         switch (fs->op_version) {  in fuse_fs_readdir_v30()
916                 if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->readdir) \  in fuse_fs_readdir_v30()
917 …return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->readdir(path, buf, filler, off, fi…  in fuse_fs_readdir_v30()
926             UNKNOWN_VERSION(fs->op_version);  in fuse_fs_readdir_v30()
936 fuse_fs_fsyncdir(struct fuse_fs* fs, const char* path, int datasync, struct fuse_file_info* fi) {  in fuse_fs_fsyncdir()  argument
937     clobber_context_user_data(fs);  in fuse_fs_fsyncdir()
939     switch (fs->op_version) {  in fuse_fs_fsyncdir()
947         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fsyncdir) \  in fuse_fs_fsyncdir()
948 …    return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fsyncdir(path, datasync, fi); \  in fuse_fs_fsyncdir()
962         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_fsyncdir()
967 fuse_fs_releasedir(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi) {  in fuse_fs_releasedir()  argument
968     clobber_context_user_data(fs);  in fuse_fs_releasedir()
969     switch (fs->op_version) {  in fuse_fs_releasedir()
979         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->releasedir) \  in fuse_fs_releasedir()
980             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->releasedir(path, fi); \  in fuse_fs_releasedir()
994         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_releasedir()
999 fuse_fs_create(struct fuse_fs* fs, const char* path, mode_t mode, struct fuse_file_info* fi) {  in fuse_fs_create()  argument
1000     clobber_context_user_data(fs);  in fuse_fs_create()
1001     switch (fs->op_version) {  in fuse_fs_create()
1011         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->create) \  in fuse_fs_create()
1012 …          return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->create(path, mode, fi); \  in fuse_fs_create()
1025         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_create()
1030 fuse_fs_lock(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi,  in fuse_fs_lock()  argument
1032     clobber_context_user_data(fs);  in fuse_fs_lock()
1034     switch (fs->op_version) {  in fuse_fs_lock()
1044         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->lock) \  in fuse_fs_lock()
1045 …       return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->lock(path, fi, cmd, lock); \  in fuse_fs_lock()
1057         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_lock()
1062 fuse_fs_flock(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi, int op) {  in fuse_fs_flock()  argument
1063     clobber_context_user_data(fs);  in fuse_fs_flock()
1065     switch (fs->op_version) {  in fuse_fs_flock()
1077         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->flock) \  in fuse_fs_flock()
1078             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->flock(path, fi, op); \  in fuse_fs_flock()
1088         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_flock()
1093 fuse_fs_chmod_v27(struct fuse_fs *fs, const char *path, mode_t mode) {  in fuse_fs_chmod_v27()  argument
1094     return fuse_fs_chmod_v30(fs, path, mode, NULL);  in fuse_fs_chmod_v27()
1098 fuse_fs_chmod_v30(struct fuse_fs* fs, const char* path,  in fuse_fs_chmod_v30()  argument
1100     clobber_context_user_data(fs);  in fuse_fs_chmod_v30()
1101     switch (fs->op_version) {  in fuse_fs_chmod_v30()
1104         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chmod) \  in fuse_fs_chmod_v30()
1105             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chmod(path, mode); \  in fuse_fs_chmod_v30()
1120         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chmod) \  in fuse_fs_chmod_v30()
1121             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chmod(path, mode, fi); \  in fuse_fs_chmod_v30()
1130         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_chmod_v30()
1134 int fuse_fs_chown_v27(struct fuse_fs *fs, const char *path, uid_t uid, gid_t gid) {  in fuse_fs_chown_v27()  argument
1135     return fuse_fs_chown_v30(fs, path, uid, gid, NULL);  in fuse_fs_chown_v27()
1139 fuse_fs_chown_v30(struct fuse_fs* fs, const char* path,  in fuse_fs_chown_v30()  argument
1141     clobber_context_user_data(fs);  in fuse_fs_chown_v30()
1142     switch (fs->op_version) {  in fuse_fs_chown_v30()
1145         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chown) \  in fuse_fs_chown_v30()
1146             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chown(path, uid, gid); \  in fuse_fs_chown_v30()
1161         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chown) \  in fuse_fs_chown_v30()
1162 …       return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->chown(path, uid, gid, fi); \  in fuse_fs_chown_v30()
1171         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_chown_v30()
1175 int fuse_fs_truncate_v27(struct fuse_fs *fs, const char *path, off_t size) {  in fuse_fs_truncate_v27()  argument
1176     return fuse_fs_truncate_v30(fs, path, size, NULL);  in fuse_fs_truncate_v27()
1180 fuse_fs_truncate_v30(struct fuse_fs* fs, const char* path, off_t size, struct fuse_file_info* fi) {  in fuse_fs_truncate_v30()  argument
1181     clobber_context_user_data(fs);  in fuse_fs_truncate_v30()
1182     switch (fs->op_version) {  in fuse_fs_truncate_v30()
1185         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate) \  in fuse_fs_truncate_v30()
1186             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate(path, size); \  in fuse_fs_truncate_v30()
1201         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate) \  in fuse_fs_truncate_v30()
1202 …        return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate(path, size, fi); \  in fuse_fs_truncate_v30()
1211         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_truncate_v30()
1216 fuse_fs_ftruncate(struct fuse_fs* fs, const char* path, off_t size, struct fuse_file_info* fi) {  in fuse_fs_ftruncate()  argument
1217     clobber_context_user_data(fs);  in fuse_fs_ftruncate()
1218     switch (fs->op_version) {  in fuse_fs_ftruncate()
1223         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate) \  in fuse_fs_ftruncate()
1224             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate(path, size); \  in fuse_fs_ftruncate()
1238         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->ftruncate) \  in fuse_fs_ftruncate()
1239 …       return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->ftruncate(path, size, fi); \  in fuse_fs_ftruncate()
1240         else if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate) \  in fuse_fs_ftruncate()
1241             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate(path, size); \  in fuse_fs_ftruncate()
1254         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate) \  in fuse_fs_ftruncate()
1255 …        return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->truncate(path, size, fi); \  in fuse_fs_ftruncate()
1264         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_ftruncate()
1269 fuse_fs_utimens_v27(struct fuse_fs *fs, const char *path, const struct timespec tv[2]) {  in fuse_fs_utimens_v27()  argument
1270     return fuse_fs_utimens_v30(fs, path, tv, NULL);  in fuse_fs_utimens_v27()
1274 fuse_fs_utimens_v30(struct fuse_fs* fs, const char* path,  in fuse_fs_utimens_v30()  argument
1281     clobber_context_user_data(fs);  in fuse_fs_utimens_v30()
1283     switch (fs->op_version) {  in fuse_fs_utimens_v30()
1288         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utime) \  in fuse_fs_utimens_v30()
1289             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utime(path, &timbuf); \  in fuse_fs_utimens_v30()
1303         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utimens) \  in fuse_fs_utimens_v30()
1304             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utimens(path, tv); \  in fuse_fs_utimens_v30()
1305         else if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utime) \  in fuse_fs_utimens_v30()
1306             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utime(path, &timbuf); \  in fuse_fs_utimens_v30()
1317         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utimens) \  in fuse_fs_utimens_v30()
1318             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->utimens(path, tv, fi); \  in fuse_fs_utimens_v30()
1327         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_utimens_v30()
1332 fuse_fs_access(struct fuse_fs* fs, const char* path, int mask) {  in fuse_fs_access()  argument
1333     clobber_context_user_data(fs);  in fuse_fs_access()
1335     switch (fs->op_version) {  in fuse_fs_access()
1343         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->access) \  in fuse_fs_access()
1344             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->access(path, mask); \  in fuse_fs_access()
1357         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_access()
1362 fuse_fs_readlink(struct fuse_fs* fs, const char* path, char* buf, size_t len) {  in fuse_fs_readlink()  argument
1363     clobber_context_user_data(fs);  in fuse_fs_readlink()
1364     switch (fs->op_version) {  in fuse_fs_readlink()
1367         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->readlink) \  in fuse_fs_readlink()
1368 …        return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->readlink(path, buf, len); \  in fuse_fs_readlink()
1385         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_readlink()
1390 fuse_fs_mknod(struct fuse_fs* fs, const char* path, mode_t mode, dev_t rdev) {  in fuse_fs_mknod()  argument
1391     clobber_context_user_data(fs);  in fuse_fs_mknod()
1392     switch (fs->op_version) {  in fuse_fs_mknod()
1395         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->mknod) \  in fuse_fs_mknod()
1396 …         return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->mknod(path, mode, rdev); \  in fuse_fs_mknod()
1413         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_mknod()
1418 fuse_fs_mkdir(struct fuse_fs* fs, const char* path, mode_t mode) {  in fuse_fs_mkdir()  argument
1419     clobber_context_user_data(fs);  in fuse_fs_mkdir()
1420     switch (fs->op_version) {  in fuse_fs_mkdir()
1423         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->mkdir) \  in fuse_fs_mkdir()
1424             return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->mkdir(path, mode); \  in fuse_fs_mkdir()
1441         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_mkdir()
1445 int fuse_fs_setxattr(struct fuse_fs* fs, const char* path, const char* name,  in fuse_fs_setxattr()  argument
1447     clobber_context_user_data(fs);  in fuse_fs_setxattr()
1449     switch (fs->op_version) {  in fuse_fs_setxattr()
1454         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->setxattr) \  in fuse_fs_setxattr()
1455 …return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->setxattr(path, name, value, size, …  in fuse_fs_setxattr()
1471         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_setxattr()
1476 fuse_fs_getxattr(struct fuse_fs* fs, const char* path, const char* name,  in fuse_fs_getxattr()  argument
1478     clobber_context_user_data(fs);  in fuse_fs_getxattr()
1480     switch (fs->op_version) {  in fuse_fs_getxattr()
1485         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getxattr) \  in fuse_fs_getxattr()
1486 …return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->getxattr(path, name, value, size);…  in fuse_fs_getxattr()
1502         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_getxattr()
1506 int fuse_fs_listxattr(struct fuse_fs* fs, const char* path, char* list, size_t size) {  in fuse_fs_listxattr()  argument
1507     clobber_context_user_data(fs);  in fuse_fs_listxattr()
1509     switch (fs->op_version) {  in fuse_fs_listxattr()
1514         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->listxattr) \  in fuse_fs_listxattr()
1515 …     return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->listxattr(path, list, size); \  in fuse_fs_listxattr()
1531         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_listxattr()
1536 fuse_fs_removexattr(struct fuse_fs* fs, const char* path, const char* name) {  in fuse_fs_removexattr()  argument
1537     clobber_context_user_data(fs);  in fuse_fs_removexattr()
1539     switch (fs->op_version) {  in fuse_fs_removexattr()
1544         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->removexattr) \  in fuse_fs_removexattr()
1545 …         return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->removexattr(path, name); \  in fuse_fs_removexattr()
1561         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_removexattr()
1566 fuse_fs_bmap(struct fuse_fs* fs, const char* path, size_t blocksize, uint64_t *idx) {  in fuse_fs_bmap()  argument
1567     clobber_context_user_data(fs);  in fuse_fs_bmap()
1569     switch (fs->op_version) {  in fuse_fs_bmap()
1577         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->bmap) \  in fuse_fs_bmap()
1578 …      return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->bmap(path, blocksize, idx); \  in fuse_fs_bmap()
1590         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_bmap()
1594 int fuse_fs_ioctl_v28(struct fuse_fs* fs, const char* path, int cmd, void* arg,  in fuse_fs_ioctl_v28()  argument
1596     return fuse_fs_ioctl_v35(fs, path, (unsigned int)cmd, arg, fi, flags, data);  in fuse_fs_ioctl_v28()
1599 int fuse_fs_ioctl_v35(struct fuse_fs* fs, const char* path, unsigned int cmd, void* arg,  in fuse_fs_ioctl_v35()  argument
1601     clobber_context_user_data(fs);  in fuse_fs_ioctl_v35()
1602     switch (fs->op_version) {  in fuse_fs_ioctl_v35()
1612         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->ioctl) \  in fuse_fs_ioctl_v35()
1613 …return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->ioctl(path, (int)cmd, arg, fi, fla…  in fuse_fs_ioctl_v35()
1625         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->ioctl) \  in fuse_fs_ioctl_v35()
1626 …return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->ioctl(path, cmd, arg, fi, flags, d…  in fuse_fs_ioctl_v35()
1633         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_ioctl_v35()
1638 fuse_fs_poll(struct fuse_fs* fs, const char* path, struct fuse_file_info* fi,  in fuse_fs_poll()  argument
1640     clobber_context_user_data(fs);  in fuse_fs_poll()
1642     switch (fs->op_version) {  in fuse_fs_poll()
1651         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->poll) \  in fuse_fs_poll()
1652 …    return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->poll(path, fi, ph, reventsp); \  in fuse_fs_poll()
1663         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_poll()
1668 fuse_fs_fallocate(struct fuse_fs* fs, const char* path, int mode, off_t offset,  in fuse_fs_fallocate()  argument
1670     clobber_context_user_data(fs);  in fuse_fs_fallocate()
1672     switch (fs->op_version) {  in fuse_fs_fallocate()
1682         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fallocate) \  in fuse_fs_fallocate()
1683 …return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->fallocate(path, mode, offset, leng…  in fuse_fs_fallocate()
1693         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_fallocate()
1698 fuse_fs_copy_file_range(struct fuse_fs *fs,  in fuse_fs_copy_file_range()  argument
1702     clobber_context_user_data(fs);  in fuse_fs_copy_file_range()
1704     switch (fs->op_version) {  in fuse_fs_copy_file_range()
1716         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->copy_file_range) \  in fuse_fs_copy_file_range()
1717 …return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->copy_file_range(path_in, fi_in, of…  in fuse_fs_copy_file_range()
1725         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_copy_file_range()
1730 fuse_fs_lseek(struct fuse_fs* fs, const char* path, off_t off, int whence,  in fuse_fs_lseek()  argument
1732     clobber_context_user_data(fs);  in fuse_fs_lseek()
1734     switch (fs->op_version) {  in fuse_fs_lseek()
1748         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->lseek) \  in fuse_fs_lseek()
1749 …    return ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->lseek(path, off, whence, fi); \  in fuse_fs_lseek()
1755         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_lseek()
1760 fuse_fs_init_v27(struct fuse_fs *fs, struct fuse_conn_info *conn) {  in fuse_fs_init_v27()  argument
1761     fuse_fs_init_v30(fs, conn, NULL);  in fuse_fs_init_v27()
1765 fuse_fs_init_v30(struct fuse_fs* fs, struct fuse_conn_info* conn,  in fuse_fs_init_v30()  argument
1767     clobber_context_user_data(fs);  in fuse_fs_init_v30()
1768     switch (fs->op_version) {  in fuse_fs_init_v30()
1777         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->init) \  in fuse_fs_init_v30()
1778             fs->user_data = ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->init(); \  in fuse_fs_init_v30()
1788         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->init) \  in fuse_fs_init_v30()
1789             fs->user_data = ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->init(conn); \  in fuse_fs_init_v30()
1800         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->init) \  in fuse_fs_init_v30()
1801 …        fs->user_data = ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->init(conn, cfg); \  in fuse_fs_init_v30()
1809         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_init_v30()
1814 fuse_fs_destroy(struct fuse_fs *fs) {  in fuse_fs_destroy()  argument
1815     clobber_context_user_data(fs);  in fuse_fs_destroy()
1816     switch (fs->op_version) {  in fuse_fs_destroy()
1825         if (((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->destroy) \  in fuse_fs_destroy()
1826             ((const struct __CONCAT(fuse_operations_v,VER)*)fs->op)->destroy(fs->user_data); \  in fuse_fs_destroy()
1839         UNKNOWN_VERSION(fs->op_version);  in fuse_fs_destroy()
1843     free(fs->op);  in fuse_fs_destroy()
1844     free(fs);  in fuse_fs_destroy()