/[fuse.before_github]/perl-llin/Fuse.xs
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /perl-llin/Fuse.xs

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

perl/trunk/Fuse.xs revision 4 by mszeredi, Thu Nov 11 14:44:15 2004 UTC perl-llin/Fuse.xs revision 71 by dpavlin, Tue Jan 3 17:27:32 2006 UTC
# Line 2  Line 2 
2  #include "perl.h"  #include "perl.h"
3  #include "XSUB.h"  #include "XSUB.h"
4    
5  #include <fuse.h>  #ifdef USE_ITHREADS
6    # ifdef I_PTHREAD
7    /* perl implements threads with pthread.  So, we use the pthread API for
8     * handling thread-local storage. */
9    #  include <pthread.h>
10    PerlInterpreter *master_interp = NULL;
11    static inline void create_perl_context() {
12            if(master_interp) {
13                    PerlInterpreter *me = PERL_GET_CONTEXT;
14                    if(!me) {
15                            PERL_SET_CONTEXT(master_interp);
16                            me = perl_clone(master_interp, CLONEf_CLONE_HOST);
17                    }
18            }
19    }
20    #  define FUSE_CONTEXT_PRE create_perl_context(); {
21    #  define FUSE_CONTEXT_POST }
22    #  define FUSE_USE_ITHREADS
23    # else
24    #  error "Sorry, I don't know how to handle ithreads on this architecture."
25    # endif
26    #else
27    # define FUSE_CONTEXT_PRE
28    # define FUSE_CONTEXT_POST
29    #endif
30    #include <fuse/fuse.h>
31    
32  #undef DEBUGf  #undef DEBUGf
33  #if 0  #if 0
34  #define DEBUGf(f, a...) fprintf(stderr, "%s:%d (%i): " f,__BASE_FILE__,__LINE__,PL_stack_sp-PL_stack_base ,##a )  #define DEBUGf(f, a...) fprintf(stderr, "%s:%d (%i): " f,__BASE_FILE__,__LINE__,sp-PL_stack_base ,##a )
35  #else  #else
36  #define DEBUGf(a...)  #define DEBUGf(a...)
37  #endif  #endif
38    
39  SV *_PLfuse_callbacks[18];  #define N_CALLBACKS 25
40    SV *_PLfuse_callbacks[N_CALLBACKS];
41    
42  int _PLfuse_getattr(const char *file, struct stat *result) {  int _PLfuse_getattr(const char *file, struct stat *result) {
         dSP;  
43          int rv, statcount;          int rv, statcount;
44            FUSE_CONTEXT_PRE;
45            dSP;
46            DEBUGf("getattr begin: %s\n",file);
47          ENTER;          ENTER;
48          SAVETMPS;          SAVETMPS;
49          PUSHMARK(SP);          PUSHMARK(SP);
# Line 32  int _PLfuse_getattr(const char *file, st Line 60  int _PLfuse_getattr(const char *file, st
60                  else                  else
61                          rv = -ENOENT;                          rv = -ENOENT;
62          } else {          } else {
63                    result->st_blocks = POPi;
64                  result->st_blksize = POPi;                  result->st_blksize = POPi;
65                  result->st_ctime = POPi;                  result->st_ctime = POPi;
66                  result->st_mtime = POPi;                  result->st_mtime = POPi;
67                  result->st_atime = POPi;                  result->st_atime = POPi;
                 /* What the HELL?  Perl says the blockcount is the last argument.  
                  * Everything else says the blockcount is the last argument.  So why  
                  * was it folded into the middle of the list? */  
                 result->st_blocks = POPi;  
68                  result->st_size = POPi;                  result->st_size = POPi;
69                  result->st_rdev = POPi;                  result->st_rdev = POPi;
70                  result->st_gid = POPi;                  result->st_gid = POPi;
# Line 53  int _PLfuse_getattr(const char *file, st Line 78  int _PLfuse_getattr(const char *file, st
78          FREETMPS;          FREETMPS;
79          LEAVE;          LEAVE;
80          PUTBACK;          PUTBACK;
81            DEBUGf("getattr end: %i\n",rv);
82            FUSE_CONTEXT_POST;
83          return rv;          return rv;
84  }  }
85    
86  int _PLfuse_readlink(const char *file,char *buf,size_t buflen) {  int _PLfuse_readlink(const char *file,char *buf,size_t buflen) {
87          int rv;          int rv;
88          char *rvstr;          char *rvstr;
         dSP;  
89          I32 ax;          I32 ax;
90            FUSE_CONTEXT_PRE;
91            dSP;
92          if(buflen < 1)          if(buflen < 1)
93                  return EINVAL;                  return EINVAL;
94            DEBUGf("readlink begin\n");
95          ENTER;          ENTER;
96          SAVETMPS;          SAVETMPS;
97          PUSHMARK(SP);          PUSHMARK(SP);
# Line 85  int _PLfuse_readlink(const char *file,ch Line 114  int _PLfuse_readlink(const char *file,ch
114          LEAVE;          LEAVE;
115          buf[buflen-1] = 0;          buf[buflen-1] = 0;
116          PUTBACK;          PUTBACK;
117            DEBUGf("readlink end: %i\n",rv);
118            FUSE_CONTEXT_POST;
119          return rv;          return rv;
120  }  }
121    
122  int _PLfuse_getdir(const char *file, fuse_dirh_t dirh, fuse_dirfil_t dirfil) {  int _PLfuse_getdir(const char *file, fuse_dirh_t dirh, fuse_dirfil_t dirfil) {
123          int prv, rv;          int prv, rv;
124            FUSE_CONTEXT_PRE;
125          dSP;          dSP;
126            DEBUGf("getdir begin\n");
127          ENTER;          ENTER;
128          SAVETMPS;          SAVETMPS;
129          PUSHMARK(SP);          PUSHMARK(SP);
# Line 109  int _PLfuse_getdir(const char *file, fus Line 142  int _PLfuse_getdir(const char *file, fus
142          FREETMPS;          FREETMPS;
143          LEAVE;          LEAVE;
144          PUTBACK;          PUTBACK;
145            DEBUGf("getdir end: %i\n",rv);
146            FUSE_CONTEXT_POST;
147          return rv;          return rv;
148  }  }
149    
# Line 116  int _PLfuse_mknod (const char *file, mod Line 151  int _PLfuse_mknod (const char *file, mod
151          int rv;          int rv;
152          SV *rvsv;          SV *rvsv;
153          char *rvstr;          char *rvstr;
154            FUSE_CONTEXT_PRE;
155          dSP;          dSP;
156            DEBUGf("mknod begin\n");
157          ENTER;          ENTER;
158          SAVETMPS;          SAVETMPS;
159          PUSHMARK(SP);          PUSHMARK(SP);
# Line 133  int _PLfuse_mknod (const char *file, mod Line 170  int _PLfuse_mknod (const char *file, mod
170          FREETMPS;          FREETMPS;
171          LEAVE;          LEAVE;
172          PUTBACK;          PUTBACK;
173            DEBUGf("mknod end: %i\n",rv);
174            FUSE_CONTEXT_POST;
175          return rv;          return rv;
176  }  }
177    
# Line 140  int _PLfuse_mkdir (const char *file, mod Line 179  int _PLfuse_mkdir (const char *file, mod
179          int rv;          int rv;
180          SV *rvsv;          SV *rvsv;
181          char *rvstr;          char *rvstr;
182            FUSE_CONTEXT_PRE;
183          dSP;          dSP;
184          DEBUGf("mkdir begin: %i\n",sp-PL_stack_base);          DEBUGf("mkdir begin\n");
185          ENTER;          ENTER;
186          SAVETMPS;          SAVETMPS;
187          PUSHMARK(SP);          PUSHMARK(SP);
# Line 157  int _PLfuse_mkdir (const char *file, mod Line 197  int _PLfuse_mkdir (const char *file, mod
197          FREETMPS;          FREETMPS;
198          LEAVE;          LEAVE;
199          PUTBACK;          PUTBACK;
200          DEBUGf("mkdir end: %i %i\n",sp-PL_stack_base,rv);          DEBUGf("mkdir end: %i\n",rv);
201            FUSE_CONTEXT_POST;
202          return rv;          return rv;
203  }  }
204    
# Line 166  int _PLfuse_unlink (const char *file) { Line 207  int _PLfuse_unlink (const char *file) {
207          int rv;          int rv;
208          SV *rvsv;          SV *rvsv;
209          char *rvstr;          char *rvstr;
210            FUSE_CONTEXT_PRE;
211          dSP;          dSP;
212          DEBUGf("unlink begin: %i\n",sp-PL_stack_base);          DEBUGf("unlink begin\n");
213          ENTER;          ENTER;
214          SAVETMPS;          SAVETMPS;
215          PUSHMARK(SP);          PUSHMARK(SP);
# Line 182  int _PLfuse_unlink (const char *file) { Line 224  int _PLfuse_unlink (const char *file) {
224          FREETMPS;          FREETMPS;
225          LEAVE;          LEAVE;
226          PUTBACK;          PUTBACK;
227          DEBUGf("unlink end: %i\n",sp-PL_stack_base);          DEBUGf("unlink end: %i\n",rv);
228            FUSE_CONTEXT_POST;
229          return rv;          return rv;
230  }  }
231    
# Line 190  int _PLfuse_rmdir (const char *file) { Line 233  int _PLfuse_rmdir (const char *file) {
233          int rv;          int rv;
234          SV *rvsv;          SV *rvsv;
235          char *rvstr;          char *rvstr;
236            FUSE_CONTEXT_PRE;
237          dSP;          dSP;
238          DEBUGf("rmdir begin: %i\n",sp-PL_stack_base);          DEBUGf("rmdir begin\n");
239          ENTER;          ENTER;
240          SAVETMPS;          SAVETMPS;
241          PUSHMARK(SP);          PUSHMARK(SP);
# Line 206  int _PLfuse_rmdir (const char *file) { Line 250  int _PLfuse_rmdir (const char *file) {
250          FREETMPS;          FREETMPS;
251          LEAVE;          LEAVE;
252          PUTBACK;          PUTBACK;
253          DEBUGf("rmdir end: %i %i\n",sp-PL_stack_base,rv);          DEBUGf("rmdir end: %i\n",rv);
254            FUSE_CONTEXT_POST;
255          return rv;          return rv;
256  }  }
257    
# Line 214  int _PLfuse_symlink (const char *file, c Line 259  int _PLfuse_symlink (const char *file, c
259          int rv;          int rv;
260          SV *rvsv;          SV *rvsv;
261          char *rvstr;          char *rvstr;
262            FUSE_CONTEXT_PRE;
263          dSP;          dSP;
264          DEBUGf("symlink begin: %i\n",sp-PL_stack_base);          DEBUGf("symlink begin\n");
265          ENTER;          ENTER;
266          SAVETMPS;          SAVETMPS;
267          PUSHMARK(SP);          PUSHMARK(SP);
# Line 231  int _PLfuse_symlink (const char *file, c Line 277  int _PLfuse_symlink (const char *file, c
277          FREETMPS;          FREETMPS;
278          LEAVE;          LEAVE;
279          PUTBACK;          PUTBACK;
280          DEBUGf("symlink end: %i\n",sp-PL_stack_base);          DEBUGf("symlink end: %i\n",rv);
281            FUSE_CONTEXT_POST;
282          return rv;          return rv;
283  }  }
284    
# Line 239  int _PLfuse_rename (const char *file, co Line 286  int _PLfuse_rename (const char *file, co
286          int rv;          int rv;
287          SV *rvsv;          SV *rvsv;
288          char *rvstr;          char *rvstr;
289            FUSE_CONTEXT_PRE;
290          dSP;          dSP;
291          DEBUGf("rename begin: %i\n",sp-PL_stack_base);          DEBUGf("rename begin\n");
292          ENTER;          ENTER;
293          SAVETMPS;          SAVETMPS;
294          PUSHMARK(SP);          PUSHMARK(SP);
# Line 256  int _PLfuse_rename (const char *file, co Line 304  int _PLfuse_rename (const char *file, co
304          FREETMPS;          FREETMPS;
305          LEAVE;          LEAVE;
306          PUTBACK;          PUTBACK;
307          DEBUGf("rename end: %i\n",sp-PL_stack_base);          DEBUGf("rename end: %i\n",rv);
308            FUSE_CONTEXT_POST;
309          return rv;          return rv;
310  }  }
311    
# Line 264  int _PLfuse_link (const char *file, cons Line 313  int _PLfuse_link (const char *file, cons
313          int rv;          int rv;
314          SV *rvsv;          SV *rvsv;
315          char *rvstr;          char *rvstr;
316            FUSE_CONTEXT_PRE;
317          dSP;          dSP;
318          DEBUGf("link begin: %i\n",sp-PL_stack_base);          DEBUGf("link begin\n");
319          ENTER;          ENTER;
320          SAVETMPS;          SAVETMPS;
321          PUSHMARK(SP);          PUSHMARK(SP);
# Line 281  int _PLfuse_link (const char *file, cons Line 331  int _PLfuse_link (const char *file, cons
331          FREETMPS;          FREETMPS;
332          LEAVE;          LEAVE;
333          PUTBACK;          PUTBACK;
334          DEBUGf("link end: %i\n",sp-PL_stack_base);          DEBUGf("link end: %i\n",rv);
335            FUSE_CONTEXT_POST;
336          return rv;          return rv;
337  }  }
338    
# Line 289  int _PLfuse_chmod (const char *file, mod Line 340  int _PLfuse_chmod (const char *file, mod
340          int rv;          int rv;
341          SV *rvsv;          SV *rvsv;
342          char *rvstr;          char *rvstr;
343            FUSE_CONTEXT_PRE;
344          dSP;          dSP;
345          DEBUGf("chmod begin: %i\n",sp-PL_stack_base);          DEBUGf("chmod begin\n");
346          ENTER;          ENTER;
347          SAVETMPS;          SAVETMPS;
348          PUSHMARK(SP);          PUSHMARK(SP);
# Line 306  int _PLfuse_chmod (const char *file, mod Line 358  int _PLfuse_chmod (const char *file, mod
358          FREETMPS;          FREETMPS;
359          LEAVE;          LEAVE;
360          PUTBACK;          PUTBACK;
361          DEBUGf("chmod end: %i\n",sp-PL_stack_base);          DEBUGf("chmod end: %i\n",rv);
362            FUSE_CONTEXT_POST;
363          return rv;          return rv;
364  }  }
365    
# Line 314  int _PLfuse_chown (const char *file, uid Line 367  int _PLfuse_chown (const char *file, uid
367          int rv;          int rv;
368          SV *rvsv;          SV *rvsv;
369          char *rvstr;          char *rvstr;
370            FUSE_CONTEXT_PRE;
371          dSP;          dSP;
372          DEBUGf("chown begin: %i\n",sp-PL_stack_base);          DEBUGf("chown begin\n");
373          ENTER;          ENTER;
374          SAVETMPS;          SAVETMPS;
375          PUSHMARK(SP);          PUSHMARK(SP);
# Line 332  int _PLfuse_chown (const char *file, uid Line 386  int _PLfuse_chown (const char *file, uid
386          FREETMPS;          FREETMPS;
387          LEAVE;          LEAVE;
388          PUTBACK;          PUTBACK;
389          DEBUGf("chown end: %i\n",sp-PL_stack_base);          DEBUGf("chown end: %i\n",rv);
390            FUSE_CONTEXT_POST;
391          return rv;          return rv;
392  }  }
393    
# Line 340  int _PLfuse_truncate (const char *file, Line 395  int _PLfuse_truncate (const char *file,
395          int rv;          int rv;
396          SV *rvsv;          SV *rvsv;
397          char *rvstr;          char *rvstr;
398            FUSE_CONTEXT_PRE;
399          dSP;          dSP;
400          DEBUGf("truncate begin: %i\n",sp-PL_stack_base);          DEBUGf("truncate begin\n");
401          ENTER;          ENTER;
402          SAVETMPS;          SAVETMPS;
403          PUSHMARK(SP);          PUSHMARK(SP);
# Line 357  int _PLfuse_truncate (const char *file, Line 413  int _PLfuse_truncate (const char *file,
413          FREETMPS;          FREETMPS;
414          LEAVE;          LEAVE;
415          PUTBACK;          PUTBACK;
416          DEBUGf("truncate end: %i\n",sp-PL_stack_base);          DEBUGf("truncate end: %i\n",rv);
417            FUSE_CONTEXT_POST;
418          return rv;          return rv;
419  }  }
420    
# Line 365  int _PLfuse_utime (const char *file, str Line 422  int _PLfuse_utime (const char *file, str
422          int rv;          int rv;
423          SV *rvsv;          SV *rvsv;
424          char *rvstr;          char *rvstr;
425            FUSE_CONTEXT_PRE;
426          dSP;          dSP;
427          DEBUGf("utime begin: %i\n",sp-PL_stack_base);          DEBUGf("utime begin\n");
428          ENTER;          ENTER;
429          SAVETMPS;          SAVETMPS;
430          PUSHMARK(SP);          PUSHMARK(SP);
# Line 383  int _PLfuse_utime (const char *file, str Line 441  int _PLfuse_utime (const char *file, str
441          FREETMPS;          FREETMPS;
442          LEAVE;          LEAVE;
443          PUTBACK;          PUTBACK;
444          DEBUGf("utime end: %i\n",sp-PL_stack_base);          DEBUGf("utime end: %i\n",rv);
445            FUSE_CONTEXT_POST;
446          return rv;          return rv;
447  }  }
448    
# Line 391  int _PLfuse_open (const char *file, int Line 450  int _PLfuse_open (const char *file, int
450          int rv;          int rv;
451          SV *rvsv;          SV *rvsv;
452          char *rvstr;          char *rvstr;
453            FUSE_CONTEXT_PRE;
454          dSP;          dSP;
455          DEBUGf("open begin: %i\n",sp-PL_stack_base);          DEBUGf("open begin\n");
456          ENTER;          ENTER;
457          SAVETMPS;          SAVETMPS;
458          PUSHMARK(SP);          PUSHMARK(SP);
# Line 408  int _PLfuse_open (const char *file, int Line 468  int _PLfuse_open (const char *file, int
468          FREETMPS;          FREETMPS;
469          LEAVE;          LEAVE;
470          PUTBACK;          PUTBACK;
471          DEBUGf("open end: %i %i\n",sp-PL_stack_base,rv);          DEBUGf("open end: %i\n",rv);
472            FUSE_CONTEXT_POST;
473          return rv;          return rv;
474  }  }
475    
476  int _PLfuse_read (const char *file, char *buf, size_t buflen, off_t off) {  int _PLfuse_read (const char *file, char *buf, size_t buflen, off_t off) {
477          int rv;          int rv;
478          char *rvstr;          char *rvstr;
479            FUSE_CONTEXT_PRE;
480          dSP;          dSP;
481          DEBUGf("read begin: %i\n",sp-PL_stack_base);          DEBUGf("read begin\n");
482          ENTER;          ENTER;
483          SAVETMPS;          SAVETMPS;
484          PUSHMARK(SP);          PUSHMARK(SP);
# Line 447  int _PLfuse_read (const char *file, char Line 509  int _PLfuse_read (const char *file, char
509          FREETMPS;          FREETMPS;
510          LEAVE;          LEAVE;
511          PUTBACK;          PUTBACK;
512          DEBUGf("read end: %i %i\n",sp-PL_stack_base,rv);          DEBUGf("read end: %i\n",rv);
513            FUSE_CONTEXT_POST;
514          return rv;          return rv;
515  }  }
516    
517  int _PLfuse_write (const char *file, const char *buf, size_t buflen, off_t off) {  int _PLfuse_write (const char *file, const char *buf, size_t buflen, off_t off) {
518          int rv;          int rv;
519          char *rvstr;          char *rvstr;
520            FUSE_CONTEXT_PRE;
521          dSP;          dSP;
522          DEBUGf("write begin: %i\n",sp-PL_stack_base);          DEBUGf("write begin\n");
523          ENTER;          ENTER;
524          SAVETMPS;          SAVETMPS;
525          PUSHMARK(SP);          PUSHMARK(SP);
# Line 472  int _PLfuse_write (const char *file, con Line 536  int _PLfuse_write (const char *file, con
536          FREETMPS;          FREETMPS;
537          LEAVE;          LEAVE;
538          PUTBACK;          PUTBACK;
539          DEBUGf("write end: %i\n",sp-PL_stack_base);          DEBUGf("write end: %i\n",rv);
540            FUSE_CONTEXT_POST;
541          return rv;          return rv;
542  }  }
543    
544  int _PLfuse_statfs (const char *file, struct statfs *st) {  /* FIXME check for old fuse API (< 21?) and use statfs here */
545    #ifdef __FreeBSD__
546     #define _fuse_statvfs statfs
547    #else
548     #define _fuse_statvfs statvfs
549    #endif
550    int _PLfuse_statfs (const char *file, struct _fuse_statvfs *st) {
551    
552          int rv;          int rv;
553          char *rvstr;          char *rvstr;
554            FUSE_CONTEXT_PRE;
555          dSP;          dSP;
556          DEBUGf("statfs begin: %i\n",sp-PL_stack_base);          DEBUGf("statfs begin\n");
557          ENTER;          ENTER;
558          SAVETMPS;          SAVETMPS;
559          PUSHMARK(SP);          PUSHMARK(SP);
560          PUTBACK;          PUTBACK;
561          rv = call_sv(_PLfuse_callbacks[17],G_ARRAY);          rv = call_sv(_PLfuse_callbacks[17],G_ARRAY);
562          SPAGAIN;          SPAGAIN;
563          if(rv > 5) {          DEBUGf("statfs got %i params\n",rv);
564                  st->f_bsize    = POPi;          if(rv == 6 || rv == 7) {
565                  st->f_bfree    = POPi;                  st->f_bsize     = POPi;
566                  st->f_blocks   = POPi;                  st->f_bfree     = POPi;
567                  st->f_ffree    = POPi;                  st->f_blocks    = POPi;
568                  st->f_files    = POPi;                  st->f_ffree     = POPi;
569                  st->f_namelen  = POPi;                  st->f_files     = POPi;
570                  if(rv > 6)                  st->f_namemax   = POPi;
571    #ifndef __FreeBSD__
572                    /* zero and fill-in other */
573                    st->f_fsid = 0;
574                    st->f_frsize = 4096;
575                    st->f_flag = 0;
576                    st->f_bavail = st->f_bfree;
577                    st->f_favail = st->f_ffree;
578    #endif
579    
580                    if(rv == 7)
581                          rv = POPi;                          rv = POPi;
582                  else                  else
583                          rv = 0;                          rv = 0;
# Line 509  int _PLfuse_statfs (const char *file, st Line 592  int _PLfuse_statfs (const char *file, st
592          FREETMPS;          FREETMPS;
593          LEAVE;          LEAVE;
594          PUTBACK;          PUTBACK;
595          DEBUGf("statfs end: %i\n",sp-PL_stack_base);          DEBUGf("statfs end: %i\n",rv);
596            FUSE_CONTEXT_POST;
597            return rv;
598    }
599    
600    int _PLfuse_flush (const char *file) {
601            int rv;
602            char *rvstr;
603            FUSE_CONTEXT_PRE;
604            dSP;
605            DEBUGf("flush begin\n");
606            ENTER;
607            SAVETMPS;
608            PUSHMARK(SP);
609            XPUSHs(sv_2mortal(newSVpv(file,0)));
610            PUTBACK;
611            rv = call_sv(_PLfuse_callbacks[18],G_SCALAR);
612            SPAGAIN;
613            if(rv)
614                    rv = POPi;
615            else
616                    rv = 0;
617            FREETMPS;
618            LEAVE;
619            PUTBACK;
620            DEBUGf("flush end: %i\n",rv);
621            FUSE_CONTEXT_POST;
622            return rv;
623    }
624    
625    int _PLfuse_release (const char *file, int flags) {
626            int rv;
627            char *rvstr;
628            FUSE_CONTEXT_PRE;
629            dSP;
630            DEBUGf("release begin\n");
631            ENTER;
632            SAVETMPS;
633            PUSHMARK(SP);
634            XPUSHs(sv_2mortal(newSVpv(file,0)));
635            XPUSHs(sv_2mortal(newSViv(flags)));
636            PUTBACK;
637            rv = call_sv(_PLfuse_callbacks[19],G_SCALAR);
638            SPAGAIN;
639            if(rv)
640                    rv = POPi;
641            else
642                    rv = 0;
643            FREETMPS;
644            LEAVE;
645            PUTBACK;
646            DEBUGf("release end: %i\n",rv);
647            FUSE_CONTEXT_POST;
648            return rv;
649    }
650    
651    int _PLfuse_fsync (const char *file, int flags) {
652            int rv;
653            char *rvstr;
654            FUSE_CONTEXT_PRE;
655            dSP;
656            DEBUGf("fsync begin\n");
657            ENTER;
658            SAVETMPS;
659            PUSHMARK(SP);
660            XPUSHs(sv_2mortal(newSVpv(file,0)));
661            XPUSHs(sv_2mortal(newSViv(flags)));
662            PUTBACK;
663            rv = call_sv(_PLfuse_callbacks[20],G_SCALAR);
664            SPAGAIN;
665            if(rv)
666                    rv = POPi;
667            else
668                    rv = 0;
669            FREETMPS;
670            LEAVE;
671            PUTBACK;
672            DEBUGf("fsync end: %i\n",rv);
673            FUSE_CONTEXT_POST;
674            return rv;
675    }
676    
677    int _PLfuse_setxattr (const char *file, const char *name, const char *buf, size_t buflen, int flags) {
678            int rv;
679            char *rvstr;
680            FUSE_CONTEXT_PRE;
681            dSP;
682            DEBUGf("setxattr begin\n");
683            ENTER;
684            SAVETMPS;
685            PUSHMARK(SP);
686            XPUSHs(sv_2mortal(newSVpv(file,0)));
687            XPUSHs(sv_2mortal(newSVpv(name,0)));
688            XPUSHs(sv_2mortal(newSVpvn(buf,buflen)));
689            XPUSHs(sv_2mortal(newSViv(flags)));
690            PUTBACK;
691            rv = call_sv(_PLfuse_callbacks[21],G_SCALAR);
692            SPAGAIN;
693            if(rv)
694                    rv = POPi;
695            else
696                    rv = 0;
697            FREETMPS;
698            LEAVE;
699            PUTBACK;
700            DEBUGf("setxattr end: %i\n",rv);
701            FUSE_CONTEXT_POST;
702            return rv;
703    }
704    
705    int _PLfuse_getxattr (const char *file, const char *name, char *buf, size_t buflen) {
706            int rv;
707            char *rvstr;
708            FUSE_CONTEXT_PRE;
709            dSP;
710            DEBUGf("getxattr begin\n");
711            ENTER;
712            SAVETMPS;
713            PUSHMARK(SP);
714            XPUSHs(sv_2mortal(newSVpv(file,0)));
715            XPUSHs(sv_2mortal(newSVpv(name,0)));
716            PUTBACK;
717            rv = call_sv(_PLfuse_callbacks[22],G_SCALAR);
718            SPAGAIN;
719            if(!rv)
720                    rv = -ENOENT;
721            else {
722                    SV *mysv = POPs;
723    
724                    rv = 0;
725                    if(SvTYPE(mysv) == SVt_NV || SvTYPE(mysv) == SVt_IV)
726                            rv = SvIV(mysv);
727                    else {
728                            if(SvPOK(mysv)) {
729                                    rv = SvCUR(mysv);
730                            } else {
731                                    rv = 0;
732                            }
733                            if ((rv > 0) && (buflen > 0))
734                            {
735                                    if(rv > buflen)
736                                            rv = -ERANGE;
737                                    else
738                                            memcpy(buf,SvPV_nolen(mysv),rv);
739                            }
740                    }
741            }
742            FREETMPS;
743            LEAVE;
744            PUTBACK;
745            DEBUGf("getxattr end: %i\n",rv);
746            FUSE_CONTEXT_POST;
747            return rv;
748    }
749    
750    int _PLfuse_listxattr (const char *file, char *list, size_t size) {
751            int prv, rv;
752            char *rvstr;
753            FUSE_CONTEXT_PRE;
754            dSP;
755            DEBUGf("listxattr begin\n");
756            ENTER;
757            SAVETMPS;
758            PUSHMARK(SP);
759            XPUSHs(sv_2mortal(newSVpv(file,0)));
760            PUTBACK;
761            prv = call_sv(_PLfuse_callbacks[23],G_ARRAY);
762            SPAGAIN;
763            if(!prv)
764                    rv = -ENOENT;
765            else {
766    
767                    char *p = list;
768                    int spc = size;
769                    int total_len = 0;
770                    int i;
771    
772                    rv = POPi;
773                    prv--;
774    
775                    /* Always nul terminate */
776                    if (list && (size > 0))
777                            list[0] = '\0';
778    
779                    while (prv > 0)
780                    {
781                            SV *mysv = POPs;
782                            prv--;
783    
784                            if (SvPOK(mysv)) {
785                                    /* Copy nul too */
786                                    int s = SvCUR(mysv) + 1;
787                                    total_len += s;
788    
789                                    if (p && (size > 0) && (spc >= s))
790                                    {
791                                            memcpy(p,SvPV_nolen(mysv),s);
792                                            p += s;
793                                            spc -= s;
794                                    }
795                            }
796                    }
797    
798                    /*
799                     * If the Perl returned an error, return that.
800                     * Otherwise check that the buffer was big enough.
801                     */
802                    if (rv == 0)
803                    {
804                            rv = total_len;
805                            if ((size > 0) && (size < total_len))
806                                    rv = -ERANGE;
807                    }
808            }
809            FREETMPS;
810            LEAVE;
811            PUTBACK;
812            DEBUGf("listxattr end: %i\n",rv);
813            FUSE_CONTEXT_POST;
814            return rv;
815    }
816    
817    int _PLfuse_removexattr (const char *file, const char *name) {
818            int rv;
819            char *rvstr;
820            FUSE_CONTEXT_PRE;
821            dSP;
822            DEBUGf("removexattr begin\n");
823            ENTER;
824            SAVETMPS;
825            PUSHMARK(SP);
826            XPUSHs(sv_2mortal(newSVpv(file,0)));
827            XPUSHs(sv_2mortal(newSVpv(name,0)));
828            PUTBACK;
829            rv = call_sv(_PLfuse_callbacks[24],G_SCALAR);
830            SPAGAIN;
831            if(rv)
832                    rv = POPi;
833            else
834                    rv = 0;
835            FREETMPS;
836            LEAVE;
837            PUTBACK;
838            DEBUGf("removexattr end: %i\n",rv);
839            FUSE_CONTEXT_POST;
840          return rv;          return rv;
841  }  }
842    
843  struct fuse_operations _available_ops = {  struct fuse_operations _available_ops = {
844  getattr:        _PLfuse_getattr,  getattr:                _PLfuse_getattr,
845                          _PLfuse_readlink,  readlink:               _PLfuse_readlink,
846                          _PLfuse_getdir,  getdir:                 _PLfuse_getdir,
847                          _PLfuse_mknod,  mknod:                  _PLfuse_mknod,
848                          _PLfuse_mkdir,  mkdir:                  _PLfuse_mkdir,
849                          _PLfuse_unlink,  unlink:                 _PLfuse_unlink,
850                          _PLfuse_rmdir,  rmdir:                  _PLfuse_rmdir,
851                          _PLfuse_symlink,  symlink:                _PLfuse_symlink,
852                          _PLfuse_rename,  rename:                 _PLfuse_rename,
853                          _PLfuse_link,  link:                   _PLfuse_link,
854                          _PLfuse_chmod,  chmod:                  _PLfuse_chmod,
855                          _PLfuse_chown,  chown:                  _PLfuse_chown,
856                          _PLfuse_truncate,  truncate:               _PLfuse_truncate,
857                          _PLfuse_utime,  utime:                  _PLfuse_utime,
858                          _PLfuse_open,  open:                   _PLfuse_open,
859                          _PLfuse_read,  read:                   _PLfuse_read,
860                          _PLfuse_write,  write:                  _PLfuse_write,
861                          _PLfuse_statfs  statfs:                 _PLfuse_statfs,
862    flush:                  _PLfuse_flush,
863    release:                _PLfuse_release,
864    fsync:                  _PLfuse_fsync,
865    setxattr:               _PLfuse_setxattr,
866    getxattr:               _PLfuse_getxattr,
867    listxattr:              _PLfuse_listxattr,
868    removexattr:            _PLfuse_removexattr,
869  };  };
870    
871  MODULE = Fuse           PACKAGE = Fuse  MODULE = Fuse           PACKAGE = Fuse
# Line 540  PROTOTYPES: DISABLE Line 874  PROTOTYPES: DISABLE
874  void  void
875  perl_fuse_main(...)  perl_fuse_main(...)
876          PREINIT:          PREINIT:
877          struct fuse_operations fops = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};          struct fuse_operations fops =
878          int i, fd, varnum = 0, debug, have_mnt;                  {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
879                     NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
880            int i, fd, varnum = 0, debug, threaded, have_mnt;
881          char *mountpoint;          char *mountpoint;
882            char *mountopts;
883          STRLEN n_a;          STRLEN n_a;
884          STRLEN l;          STRLEN l;
885          INIT:          INIT:
886          if(items != 20) {          if(items != 29) {
887                  fprintf(stderr,"Perl<->C inconsistency or internal error\n");                  fprintf(stderr,"Perl<->C inconsistency or internal error\n");
888                  XSRETURN_UNDEF;                  XSRETURN_UNDEF;
889          }          }
890          CODE:          CODE:
891          debug = SvIV(ST(0));          debug = SvIV(ST(0));
892          mountpoint = SvPV_nolen(ST(1));          threaded = SvIV(ST(1));
893          /* FIXME: reevaluate multithreading support when perl6 arrives */          if(threaded) {
894          for(i=0;i<18;i++) {  #ifdef FUSE_USE_ITHREADS
895                  SV *var = ST(i+2);                  master_interp = PERL_GET_INTERP;
896                  if((var != &PL_sv_undef) && SvROK(var)) {  #else
897                          if(SvTYPE(SvRV(var)) == SVt_PVCV) {                  fprintf(stderr,"FUSE warning: Your script has requested multithreaded "
898                                  void **tmp1 = (void**)&_available_ops, **tmp2 = (void**)&fops;                                 "mode, but your perl was not built with -Dusethreads.  "
899                                  tmp2[i] = tmp1[i];                                 "Threads are disabled.\n");
900                                  _PLfuse_callbacks[i] = var;                  threaded = 0;
901                          } else  #endif
902                                  croak("arg is not a code reference!");          }
903            mountpoint = SvPV_nolen(ST(2));
904            mountopts = SvPV_nolen(ST(3));
905            for(i=0;i<N_CALLBACKS;i++) {
906                    SV *var = ST(i+4);
907                    /* allow symbolic references, or real code references. */
908                    if(SvOK(var) && (SvPOK(var) || (SvROK(var) && SvTYPE(SvRV(var)) == SVt_PVCV))) {
909                            void **tmp1 = (void**)&_available_ops, **tmp2 = (void**)&fops;
910                            tmp2[i] = tmp1[i];
911    #ifdef FUSE_USE_ITHREADS
912                            if(threaded)
913                    /* note: under 5.8.7, this croaks for code references. */
914                    SvSHARE(var);
915    #endif
916                            _PLfuse_callbacks[i] = var;
917                    } else
918                    if(SvOK(var)) {
919                            croak("invalid callback passed to perl_fuse_main "
920                                  "(%s is not a string, code ref, or undef).\n",
921                                  i+4,SvPVbyte_nolen(var));
922                  }                  }
923          }          }
924          /* FIXME: need to pass fusermount arguments */          /* FIXME: need to pass fusermount arguments */
925          fd = fuse_mount(mountpoint,NULL);          fd = fuse_mount(mountpoint,mountopts);
926          if(fd < 0)          if(fd < 0)
927                  croak("could not mount fuse filesystem!");                  croak("could not mount fuse filesystem!");
928          fuse_loop(fuse_new(fd,debug ? "debug" : NULL,&fops));          if(threaded) {
929                    fuse_loop_mt(fuse_new(fd,debug ? "debug" : NULL,&fops));
930            } else
931                    fuse_loop(fuse_new(fd,debug ? "debug" : NULL,&fops));

Legend:
Removed from v.4  
changed lines
  Added in v.71

  ViewVC Help
Powered by ViewVC 1.1.26