← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to docs-xml/Samba3-Developers-Guide/vfs.xml

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
docs-xml/Samba3-Developers-Guide/vfs.xml
 
1
<?xml version="1.0" encoding="iso-8859-1"?>
 
2
<!DOCTYPE chapter PUBLIC "-//Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc">
 
3
<chapter id="vfs">
 
4
<chapterinfo>
 
5
        <author>
 
6
                <firstname>Alexander</firstname><surname>Bokovoy</surname>
 
7
                <affiliation>
 
8
                        <address><email>ab@samba.org</email></address>
 
9
                </affiliation>
 
10
        </author>
 
11
        <author>
 
12
                <firstname>Stefan</firstname><surname>Metzmacher</surname>
 
13
                <affiliation>
 
14
                        <address><email>metze@samba.org</email></address>
 
15
                </affiliation>
 
16
        </author>
 
17
        <pubdate> 27 May 2003 </pubdate>
 
18
</chapterinfo>
 
19
 
 
20
<title>VFS Modules</title>
 
21
 
 
22
<sect1>
 
23
<title>The Samba (Posix) VFS layer</title>
 
24
 
 
25
<para>While most of Samba deployments are done using POSIX-compatible
 
26
operating systems, there is clearly more to a file system than what is
 
27
required by POSIX when it comes to adopting semantics of NT file
 
28
system. Since Samba 2.2 all file-system related operations go through
 
29
an abstraction layer for virtual file system (VFS) that is modelled
 
30
after both POSIX and additional functions needed to transform NTFS
 
31
semantics.
 
32
</para>
 
33
 
 
34
<para>
 
35
This abstraction layer now provides more features than a regular POSIX
 
36
file system could fill in. It is not required that all of them should
 
37
be implemented by your particular file system.  However, when those
 
38
features are available, Samba would advertize them to a CIFS client
 
39
and they might be used by an application and in case of Windows client
 
40
that might mean a client expects even more additional functionality
 
41
when it encounters those features. There is a practical reason to
 
42
allow handling of this snowfall without modifying the Samba core and
 
43
it is fulfilled by providing an infrastructure to dynamically load VFS
 
44
modules at run time.
 
45
</para>
 
46
 
 
47
<para>Each VFS module could implement a number of VFS operations. The
 
48
way it does it is irrelevant, only two things actually matter: whether
 
49
specific implementation wants to cooperate with other modules'
 
50
implementations or not, and whether module needs to store additional
 
51
information that is specific to a context it is operating in. Multiple
 
52
VFS modules could be loaded at the same time and it is even possible
 
53
to load several instances of the same VFS module with different
 
54
parameters.
 
55
</para>
 
56
 
 
57
<sect2>
 
58
<title>The general interface</title>
 
59
 
 
60
<para>A VFS module has three major components:
 
61
<itemizedlist>
 
62
<listitem><emphasis>An initialization function</emphasis> that is
 
63
called during the module load to register implemented
 
64
operations.</listitem>
 
65
<listitem><emphasis>An operations table</emphasis> representing a
 
66
mapping between statically defined module functions and VFS layer
 
67
operations.</listitem>
 
68
<listitem><emphasis>Module functions</emphasis> that do actual
 
69
work.</listitem>
 
70
</itemizedlist>
 
71
</para>
 
72
 
 
73
<para>While this structure has been first applied to the VFS
 
74
subsystem, it is now commonly used across all Samba 3 subsystems that
 
75
support loadable modules. In fact, one module could provide a number
 
76
of interfaces to different subsystems by exposing different
 
77
<emphasis>operation tables</emphasis> through separate
 
78
<emphasis>initialization functions</emphasis>.</para>
 
79
 
 
80
<para><emphasis>An initialization function</emphasis> is used to
 
81
register module with Samba run-time. As Samba internal structures and
 
82
API are changed over lifetime, each released version has a VFS
 
83
interface version that is increased as VFS development progresses or
 
84
any of underlying Samba structures are changed in binary-incompatible
 
85
way. When VFS module is compiled in, VFS interface version of that
 
86
Samba environment is embedded into the module's binary object and is
 
87
checked by the Samba core upon module load. If VFS interface number
 
88
reported by the module isn't the same Samba core knows about, version
 
89
conflict is detected and module dropped to avoid any potential memory
 
90
corruption when accessing (changed) Samba structures.
 
91
</para>
 
92
 
 
93
<para>Therefore, initialization function passes three parameters to the
 
94
VFS registration function, <literal>smb_register_vfs()</literal>
 
95
<itemizedlist>
 
96
  <listitem><emphasis>interface version number</emphasis>, as constant
 
97
  <literal>SMB_VFS_INTERFACE_VERSION</literal>, </listitem>
 
98
  <listitem><emphasis>module name</emphasis>, under which Samba core
 
99
  will know it, and</listitem>
 
100
  <listitem><emphasis>an operations' table</emphasis>.</listitem>
 
101
</itemizedlist>
 
102
</para>
 
103
 
 
104
<para>The <emphasis>operations' table</emphasis> defines which
 
105
functions in the module would correspond to specific VFS operations
 
106
and how those functions would co-operate with the rest of VFS
 
107
subsystem. Each operation could perform in a following ways:
 
108
<itemizedlist>
 
109
  <listitem><emphasis>transparent</emphasis>, meaning that while
 
110
  operation is overriden, the module will still call a previous
 
111
  implementation, before or after its own action. This mode is
 
112
  indicated by the constant
 
113
  <literal>SMB_VFS_LAYER_TRANSPARENT</literal>;
 
114
  </listitem>
 
115
  <listitem><emphasis>opaque</emphasis>, for the implementations that
 
116
  are terminating sequence of actions. For example, it is used to
 
117
  implement POSIX operation on top of non-POSIX file system or even
 
118
  not a file system at all, like a database for a personal audio
 
119
  collection. Use constant <literal>SMB_VFS_LAYER_OPAQUE</literal> for
 
120
  this mode;</listitem>
 
121
  <listitem><emphasis>splitter</emphasis>, a way when some file system
 
122
  activity is done in addition to the transparently calling previous
 
123
  implentation. This usually involves mangling the result of that call
 
124
  before returning it back to the caller. This mode is selected by
 
125
  <literal>SMB_VFS_LAYER_SPLITTER</literal> constant;</listitem>
 
126
  <listitem><emphasis>logger</emphasis> does not change anything or
 
127
  performs any additional VFS operations. When
 
128
  <emphasis>logger</emphasis> module acts, information about
 
129
  operations is logged somewhere using an external facility (or
 
130
  Samba's own debugging tools) but not the VFS layer. In order to
 
131
  describe this type of activity use constant
 
132
  <literal>SMB_VFS_LAYER_LOGGER</literal>;
 
133
  </listitem>
 
134
  <listitem>On contrary, <emphasis>scanner</emphasis> module does call
 
135
  other VFS operations while processing the data that goes through the
 
136
  system. This type of operation is indicated by the
 
137
  <literal>SMB_VFS_LAYER_SCANNER</literal> constant.</listitem>
 
138
</itemizedlist>
 
139
</para>
 
140
 
 
141
<para>Fundamentally, there are three types:
 
142
<emphasis>transparent</emphasis>, <emphasis>opaque</emphasis>, and
 
143
<emphasis>logger</emphasis>. <emphasis>Splitter</emphasis> and
 
144
<emphasis>scanner</emphasis> may confuse developers (and indeed they
 
145
are confused as our experience has shown) but this separation is to
 
146
better expose the nature of a module's actions. Most of modules
 
147
developed so far are either one of those three fundamental types with
 
148
transparent and opaque being prevalent.
 
149
</para>
 
150
 
 
151
<para>
 
152
Each VFS operation has a vfs_op_type, a function pointer and a handle
 
153
pointer in the struct vfs_ops and tree macros to make it easier to
 
154
call the operations.  (Take a look at
 
155
<filename>include/vfs.h</filename> and
 
156
<filename>include/vfs_macros.h</filename>.)
 
157
</para>
 
158
 
 
159
<para><programlisting>
 
160
typedef enum _vfs_op_type {
 
161
        SMB_VFS_OP_NOOP = -1,
 
162
 
 
163
        ...
 
164
 
 
165
        /* File operations */
 
166
 
 
167
        SMB_VFS_OP_OPEN,
 
168
        SMB_VFS_OP_CLOSE,
 
169
        SMB_VFS_OP_READ,
 
170
        SMB_VFS_OP_WRITE,
 
171
        SMB_VFS_OP_LSEEK,
 
172
        SMB_VFS_OP_SENDFILE,
 
173
 
 
174
        ...
 
175
 
 
176
        SMB_VFS_OP_LAST
 
177
} vfs_op_type;
 
178
</programlisting></para>
 
179
 
 
180
<para>This struct contains the function and handle pointers for all operations.<programlisting>
 
181
struct vfs_ops {
 
182
        struct vfs_fn_pointers {
 
183
                ...
 
184
                
 
185
                /* File operations */
 
186
                
 
187
                int (*open)(struct vfs_handle_struct *handle,
 
188
                        struct connection_struct *conn,
 
189
                        const char *fname, int flags, mode_t mode);
 
190
                int (*close)(struct vfs_handle_struct *handle,
 
191
                        struct files_struct *fsp, int fd);
 
192
                ssize_t (*read)(struct vfs_handle_struct *handle, 
 
193
                        struct files_struct *fsp, int fd, void *data, size_t n);
 
194
                ssize_t (*write)(struct vfs_handle_struct *handle, 
 
195
                        struct files_struct *fsp, int fd, 
 
196
                        const void *data, size_t n);
 
197
                SMB_OFF_T (*lseek)(struct vfs_handle_struct *handle, 
 
198
                        struct files_struct *fsp, int fd, 
 
199
                        SMB_OFF_T offset, int whence);
 
200
                ssize_t (*sendfile)(struct vfs_handle_struct *handle, 
 
201
                        int tofd, files_struct *fsp, int fromfd, 
 
202
                        const DATA_BLOB *header, SMB_OFF_T offset, size_t count);
 
203
 
 
204
                ...
 
205
        } ops;
 
206
        
 
207
        struct vfs_handles_pointers {
 
208
                ...
 
209
                
 
210
                /* File operations */
 
211
                
 
212
                struct vfs_handle_struct *open;
 
213
                struct vfs_handle_struct *close;
 
214
                struct vfs_handle_struct *read;
 
215
                struct vfs_handle_struct *write;
 
216
                struct vfs_handle_struct *lseek;
 
217
                struct vfs_handle_struct *sendfile;
 
218
                
 
219
                ...
 
220
        } handles;
 
221
};
 
222
</programlisting></para>
 
223
 
 
224
<para>
 
225
This macros SHOULD be used to call any vfs operation.
 
226
DO NOT ACCESS conn-&gt;vfs.ops.* directly !!!
 
227
<programlisting>
 
228
...
 
229
        
 
230
/* File operations */
 
231
#define SMB_VFS_OPEN(conn, fname, flags, mode) \
 
232
        ((conn)-&gt;vfs.ops.open((conn)-&gt;vfs.handles.open,\
 
233
         (conn), (fname), (flags), (mode)))
 
234
#define SMB_VFS_CLOSE(fsp, fd) \
 
235
        ((fsp)-&gt;conn-&gt;vfs.ops.close(\
 
236
        (fsp)-&gt;conn-&gt;vfs.handles.close, (fsp), (fd)))
 
237
#define SMB_VFS_READ(fsp, fd, data, n) \
 
238
        ((fsp)-&gt;conn-&gt;vfs.ops.read(\
 
239
        (fsp)-&gt;conn-&gt;vfs.handles.read,\
 
240
         (fsp), (fd), (data), (n)))
 
241
#define SMB_VFS_WRITE(fsp, fd, data, n) \
 
242
        ((fsp)-&gt;conn-&gt;vfs.ops.write(\
 
243
        (fsp)-&gt;conn-&gt;vfs.handles.write,\
 
244
         (fsp), (fd), (data), (n)))
 
245
#define SMB_VFS_LSEEK(fsp, fd, offset, whence) \
 
246
        ((fsp)-&gt;conn-&gt;vfs.ops.lseek(\
 
247
        (fsp)-&gt;conn-&gt;vfs.handles.lseek,\
 
248
         (fsp), (fd), (offset), (whence)))
 
249
#define SMB_VFS_SENDFILE(tofd, fsp, fromfd, header, offset, count) \
 
250
        ((fsp)-&gt;conn-&gt;vfs.ops.sendfile(\
 
251
        (fsp)-&gt;conn-&gt;vfs.handles.sendfile,\
 
252
         (tofd), (fsp), (fromfd), (header), (offset), (count)))
 
253
 
 
254
...
 
255
</programlisting></para>
 
256
 
 
257
</sect2>
 
258
 
 
259
<sect2>
 
260
<title>Possible VFS operation layers</title>
 
261
 
 
262
<para>
 
263
These values are used by the VFS subsystem when building the conn-&gt;vfs 
 
264
and conn-&gt;vfs_opaque structs for a connection with multiple VFS modules. 
 
265
Internally, Samba differentiates only opaque and transparent layers at this process.
 
266
Other types are used for providing better diagnosing facilities.
 
267
</para>
 
268
 
 
269
<para>
 
270
Most modules will provide transparent layers. Opaque layer is for modules
 
271
which implement actual file system calls (like DB-based VFS). For example,
 
272
default POSIX VFS which is built in into Samba is an opaque VFS module.
 
273
</para>
 
274
 
 
275
<para>    
 
276
Other layer types (logger, splitter, scanner) were designed to provide different 
 
277
degree of transparency and for diagnosing VFS module behaviour.
 
278
</para>
 
279
 
 
280
<para>
 
281
Each module can implement several layers at the same time provided that only
 
282
one layer is used per each operation.
 
283
</para>
 
284
 
 
285
<para><programlisting>
 
286
typedef enum _vfs_op_layer {
 
287
        SMB_VFS_LAYER_NOOP = -1,        /* - For using in VFS module to indicate end of array */
 
288
                                        /*   of operations description */
 
289
        SMB_VFS_LAYER_OPAQUE = 0,       /* - Final level, does not call anything beyond itself */
 
290
        SMB_VFS_LAYER_TRANSPARENT,      /* - Normal operation, calls underlying layer after */
 
291
                                        /*   possibly changing passed data */
 
292
        SMB_VFS_LAYER_LOGGER,           /* - Logs data, calls underlying layer, logging may not */
 
293
                                        /*   use Samba VFS */
 
294
        SMB_VFS_LAYER_SPLITTER,         /* - Splits operation, calls underlying layer _and_ own facility, */
 
295
                                        /*   then combines result */
 
296
        SMB_VFS_LAYER_SCANNER           /* - Checks data and possibly initiates additional */
 
297
                                        /*   file activity like logging to files _inside_ samba VFS */
 
298
} vfs_op_layer;
 
299
</programlisting></para>
 
300
 
 
301
</sect2>
 
302
 
 
303
</sect1>
 
304
 
 
305
<sect1>
 
306
<title>The Interaction between the Samba VFS subsystem and the modules</title>
 
307
 
 
308
<sect2>
 
309
<title>Initialization and registration</title>
 
310
 
 
311
<para>
 
312
As each Samba module a VFS module should have a 
 
313
<programlisting>NTSTATUS vfs_example_init(void);</programlisting> function if it's staticly linked to samba or
 
314
<programlisting>NTSTATUS init_module(void);</programlisting> function if it's a shared module.
 
315
</para>
 
316
 
 
317
<para>
 
318
This should be the only non static function inside the module.
 
319
Global variables should also be static!
 
320
</para>
 
321
 
 
322
<para>
 
323
The module should register its functions via the
 
324
<programlisting>
 
325
NTSTATUS smb_register_vfs(int version, const char *name, vfs_op_tuple *vfs_op_tuples);
 
326
</programlisting> function.
 
327
</para>
 
328
 
 
329
<variablelist>
 
330
 
 
331
<varlistentry><term>version</term>
 
332
<listitem><para>should be filled with SMB_VFS_INTERFACE_VERSION</para></listitem>
 
333
</varlistentry>
 
334
 
 
335
<varlistentry><term>name</term>
 
336
<listitem><para>this is the name witch can be listed in the 
 
337
<command>vfs objects</command> parameter to use this module.</para></listitem>
 
338
</varlistentry>
 
339
 
 
340
<varlistentry><term>vfs_op_tuples</term>
 
341
<listitem><para>
 
342
this is an array of vfs_op_tuple's.
 
343
(vfs_op_tuples is descripted in details below.)
 
344
</para></listitem>
 
345
</varlistentry>
 
346
 
 
347
</variablelist>
 
348
 
 
349
<para>
 
350
For each operation the module wants to provide it has a entry in the 
 
351
vfs_op_tuple array.
 
352
</para>
 
353
 
 
354
<programlisting>
 
355
typedef struct _vfs_op_tuple {
 
356
        void* op;
 
357
        vfs_op_type type;
 
358
        vfs_op_layer layer;
 
359
} vfs_op_tuple;
 
360
</programlisting>
 
361
 
 
362
<variablelist>
 
363
 
 
364
<varlistentry><term>op</term>
 
365
<listitem><para>the function pointer to the specified function.</para></listitem>
 
366
</varlistentry>
 
367
 
 
368
<varlistentry><term>type</term>
 
369
<listitem><para>the vfs_op_type of the function to specified witch operation the function provides.</para></listitem>
 
370
</varlistentry>
 
371
 
 
372
<varlistentry><term>layer</term>
 
373
<listitem><para>the vfs_op_layer in whitch the function operates.</para></listitem>
 
374
</varlistentry>
 
375
 
 
376
</variablelist>
 
377
 
 
378
<para>A simple example:</para>
 
379
 
 
380
<programlisting>
 
381
static vfs_op_tuple example_op_tuples[] = {     
 
382
        {SMB_VFS_OP(example_connect),   SMB_VFS_OP_CONNECT,     SMB_VFS_LAYER_TRANSPARENT},
 
383
        {SMB_VFS_OP(example_disconnect),        SMB_VFS_OP_DISCONNECT,  SMB_VFS_LAYER_TRANSPARENT},
 
384
 
 
385
        {SMB_VFS_OP(example_rename),    SMB_VFS_OP_RENAME,      SMB_VFS_LAYER_OPAQUE},
 
386
 
 
387
        /* This indicates the end of the array */
 
388
        {SMB_VFS_OP(NULL),                              SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
 
389
};
 
390
 
 
391
NTSTATUS init_module(void)
 
392
{
 
393
        return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, &quot;example&quot;, example_op_tuples);
 
394
}
 
395
</programlisting>
 
396
 
 
397
</sect2>
 
398
 
 
399
<sect2>
 
400
<title>How the Modules handle per connection data</title>
 
401
 
 
402
<para>Each VFS function has as first parameter a pointer to the modules vfs_handle_struct.
 
403
</para>
 
404
 
 
405
<programlisting>
 
406
typedef struct vfs_handle_struct {
 
407
        struct vfs_handle_struct  *next, *prev;
 
408
        const char *param;
 
409
        struct vfs_ops vfs_next;
 
410
        struct connection_struct *conn;
 
411
        void *data;
 
412
        void (*free_data)(void **data);
 
413
} vfs_handle_struct;
 
414
</programlisting>
 
415
 
 
416
<variablelist>
 
417
 
 
418
<varlistentry><term>param</term>
 
419
<listitem><para>this is the module parameter specified in the <command>vfs objects</command> parameter.</para>
 
420
<para>e.g. for 'vfs objects = example:test' param would be &quot;test&quot;.</para></listitem>
 
421
</varlistentry>
 
422
 
 
423
<varlistentry><term>vfs_next</term>
 
424
<listitem><para>This vfs_ops struct contains the information for calling the next module operations.
 
425
Use the SMB_VFS_NEXT_* macros to call a next module operations and
 
426
don't access handle-&gt;vfs_next.ops.* directly!</para></listitem>
 
427
</varlistentry>
 
428
 
 
429
<varlistentry><term>conn</term>
 
430
<listitem><para>This is a pointer back to the connection_struct to witch the handle belongs.</para></listitem>
 
431
</varlistentry>
 
432
 
 
433
<varlistentry><term>data</term>
 
434
<listitem><para>This is a pointer for holding module private data.
 
435
You can alloc data with connection life time on the handle-&gt;conn-&gt;mem_ctx TALLOC_CTX.
 
436
But you can also manage the memory allocation yourself.</para></listitem>
 
437
</varlistentry>
 
438
 
 
439
<varlistentry><term>free_data</term>
 
440
<listitem><para>This is a function pointer to a function that free's the module private data.
 
441
If you talloc your private data on the TALLOC_CTX handle-&gt;conn-&gt;mem_ctx,
 
442
you can set this function pointer to NULL.</para></listitem>
 
443
</varlistentry>
 
444
 
 
445
</variablelist>
 
446
 
 
447
<para>Some useful MACROS for handle private data.
 
448
</para>
 
449
 
 
450
<programlisting>
 
451
#define SMB_VFS_HANDLE_GET_DATA(handle, datap, type, ret) { \
 
452
        if (!(handle)||((datap=(type *)(handle)-&gt;data)==NULL)) { \
 
453
                DEBUG(0,(&quot;%s() failed to get vfs_handle-&gt;data!\n&quot;,FUNCTION_MACRO)); \
 
454
                ret; \
 
455
        } \
 
456
}
 
457
 
 
458
#define SMB_VFS_HANDLE_SET_DATA(handle, datap, free_fn, type, ret) { \
 
459
        if (!(handle)) { \
 
460
                DEBUG(0,(&quot;%s() failed to set handle-&gt;data!\n&quot;,FUNCTION_MACRO)); \
 
461
                ret; \
 
462
        } else { \
 
463
                if ((handle)-&gt;free_data) { \
 
464
                        (handle)-&gt;free_data(&amp;(handle)-&gt;data); \
 
465
                } \
 
466
                (handle)-&gt;data = (void *)datap; \
 
467
                (handle)-&gt;free_data = free_fn; \
 
468
        } \
 
469
}
 
470
 
 
471
#define SMB_VFS_HANDLE_FREE_DATA(handle) { \
 
472
        if ((handle) &amp;&amp; (handle)-&gt;free_data) { \
 
473
                (handle)-&gt;free_data(&amp;(handle)-&gt;data); \
 
474
        } \
 
475
}
 
476
</programlisting>
 
477
 
 
478
<para>How SMB_VFS_LAYER_TRANSPARENT functions can call the SMB_VFS_LAYER_OPAQUE functions.</para>
 
479
 
 
480
<para>The easiest way to do this is to use the SMB_VFS_OPAQUE_* macros.
 
481
</para>
 
482
 
 
483
<programlisting>
 
484
...
 
485
/* File operations */
 
486
#define SMB_VFS_OPAQUE_OPEN(conn, fname, flags, mode) \
 
487
        ((conn)-&gt;vfs_opaque.ops.open(\
 
488
        (conn)-&gt;vfs_opaque.handles.open,\
 
489
         (conn), (fname), (flags), (mode)))
 
490
#define SMB_VFS_OPAQUE_CLOSE(fsp, fd) \
 
491
        ((fsp)-&gt;conn-&gt;vfs_opaque.ops.close(\
 
492
        (fsp)-&gt;conn-&gt;vfs_opaque.handles.close,\
 
493
         (fsp), (fd)))
 
494
#define SMB_VFS_OPAQUE_READ(fsp, fd, data, n) \
 
495
        ((fsp)-&gt;conn-&gt;vfs_opaque.ops.read(\
 
496
        (fsp)-&gt;conn-&gt;vfs_opaque.handles.read,\
 
497
         (fsp), (fd), (data), (n)))
 
498
#define SMB_VFS_OPAQUE_WRITE(fsp, fd, data, n) \
 
499
        ((fsp)-&gt;conn-&gt;vfs_opaque.ops.write(\
 
500
        (fsp)-&gt;conn-&gt;vfs_opaque.handles.write,\
 
501
         (fsp), (fd), (data), (n)))
 
502
#define SMB_VFS_OPAQUE_LSEEK(fsp, fd, offset, whence) \
 
503
        ((fsp)-&gt;conn-&gt;vfs_opaque.ops.lseek(\
 
504
        (fsp)-&gt;conn-&gt;vfs_opaque.handles.lseek,\
 
505
         (fsp), (fd), (offset), (whence)))
 
506
#define SMB_VFS_OPAQUE_SENDFILE(tofd, fsp, fromfd, header, offset, count) \
 
507
        ((fsp)-&gt;conn-&gt;vfs_opaque.ops.sendfile(\
 
508
        (fsp)-&gt;conn-&gt;vfs_opaque.handles.sendfile,\
 
509
         (tofd), (fsp), (fromfd), (header), (offset), (count)))
 
510
...
 
511
</programlisting>
 
512
 
 
513
<para>How SMB_VFS_LAYER_TRANSPARENT functions can call the next modules functions.</para>
 
514
 
 
515
<para>The easiest way to do this is to use the SMB_VFS_NEXT_* macros.
 
516
</para>
 
517
 
 
518
<programlisting>
 
519
...
 
520
/* File operations */
 
521
#define SMB_VFS_NEXT_OPEN(handle, conn, fname, flags, mode) \
 
522
        ((handle)-&gt;vfs_next.ops.open(\
 
523
        (handle)-&gt;vfs_next.handles.open,\
 
524
         (conn), (fname), (flags), (mode)))
 
525
#define SMB_VFS_NEXT_CLOSE(handle, fsp, fd) \
 
526
        ((handle)-&gt;vfs_next.ops.close(\
 
527
        (handle)-&gt;vfs_next.handles.close,\
 
528
         (fsp), (fd)))
 
529
#define SMB_VFS_NEXT_READ(handle, fsp, fd, data, n) \
 
530
        ((handle)-&gt;vfs_next.ops.read(\
 
531
        (handle)-&gt;vfs_next.handles.read,\
 
532
         (fsp), (fd), (data), (n)))
 
533
#define SMB_VFS_NEXT_WRITE(handle, fsp, fd, data, n) \
 
534
        ((handle)-&gt;vfs_next.ops.write(\
 
535
        (handle)-&gt;vfs_next.handles.write,\
 
536
         (fsp), (fd), (data), (n)))
 
537
#define SMB_VFS_NEXT_LSEEK(handle, fsp, fd, offset, whence) \
 
538
        ((handle)-&gt;vfs_next.ops.lseek(\
 
539
        (handle)-&gt;vfs_next.handles.lseek,\
 
540
         (fsp), (fd), (offset), (whence)))
 
541
#define SMB_VFS_NEXT_SENDFILE(handle, tofd, fsp, fromfd, header, offset, count) \
 
542
        ((handle)-&gt;vfs_next.ops.sendfile(\
 
543
        (handle)-&gt;vfs_next.handles.sendfile,\
 
544
         (tofd), (fsp), (fromfd), (header), (offset), (count)))
 
545
...
 
546
</programlisting>
 
547
 
 
548
</sect2>
 
549
 
 
550
</sect1>
 
551
 
 
552
<sect1>
 
553
<title>Upgrading to the New VFS Interface</title>
 
554
 
 
555
<sect2>
 
556
<title>Upgrading from 2.2.* and 3.0alpha modules</title>
 
557
 
 
558
<orderedlist>
 
559
<listitem><para>
 
560
Add &quot;vfs_handle_struct *handle, &quot; as first parameter to all vfs operation functions.
 
561
e.g. example_connect(connection_struct *conn, const char *service, const char *user);
 
562
-&gt;   example_connect(vfs_handle_struct *handle, connection_struct *conn, const char *service, const char *user);
 
563
</para></listitem>
 
564
 
 
565
<listitem><para>
 
566
Replace &quot;default_vfs_ops.&quot; with &quot;smb_vfs_next_&quot;.
 
567
e.g. default_vfs_ops.connect(conn, service, user);
 
568
-&gt;   smb_vfs_next_connect(conn, service, user);
 
569
</para></listitem>
 
570
 
 
571
<listitem><para>
 
572
Uppercase all &quot;smb_vfs_next_*&quot; functions.
 
573
e.g. smb_vfs_next_connect(conn, service, user);
 
574
-&gt;   SMB_VFS_NEXT_CONNECT(conn, service, user);
 
575
</para></listitem>
 
576
 
 
577
<listitem><para>
 
578
Add &quot;handle, &quot; as first parameter to all SMB_VFS_NEXT_*() calls.
 
579
e.g. SMB_VFS_NEXT_CONNECT(conn, service, user);
 
580
-&gt;   SMB_VFS_NEXT_CONNECT(handle, conn, service, user);
 
581
</para></listitem>
 
582
 
 
583
<listitem><para>
 
584
(Only for 2.2.* modules) 
 
585
Convert the old struct vfs_ops example_ops to 
 
586
a vfs_op_tuple example_op_tuples[] array.
 
587
e.g.
 
588
<programlisting>
 
589
struct vfs_ops example_ops = {
 
590
        /* Disk operations */
 
591
        example_connect,                /* connect */
 
592
        example_disconnect,             /* disconnect */
 
593
        NULL,                           /* disk free *
 
594
        /* Directory operations */
 
595
        NULL,                           /* opendir */
 
596
        NULL,                           /* readdir */
 
597
        NULL,                           /* mkdir */
 
598
        NULL,                           /* rmdir */
 
599
        NULL,                           /* closedir */
 
600
        /* File operations */
 
601
        NULL,                           /* open */
 
602
        NULL,                           /* close */
 
603
        NULL,                           /* read  */
 
604
        NULL,                           /* write */
 
605
        NULL,                           /* lseek */
 
606
        NULL,                           /* sendfile */
 
607
        NULL,                           /* rename */
 
608
        NULL,                           /* fsync */
 
609
        example_stat,                   /* stat  */
 
610
        example_fstat,                  /* fstat */
 
611
        example_lstat,                  /* lstat */
 
612
        NULL,                           /* unlink */
 
613
        NULL,                           /* chmod */
 
614
        NULL,                           /* fchmod */
 
615
        NULL,                           /* chown */
 
616
        NULL,                           /* fchown */
 
617
        NULL,                           /* chdir */
 
618
        NULL,                           /* getwd */
 
619
        NULL,                           /* utime */
 
620
        NULL,                           /* ftruncate */
 
621
        NULL,                           /* lock */
 
622
        NULL,                           /* symlink */
 
623
        NULL,                           /* readlink */
 
624
        NULL,                           /* link */
 
625
        NULL,                           /* mknod */
 
626
        NULL,                           /* realpath */
 
627
        NULL,                           /* fget_nt_acl */
 
628
        NULL,                           /* get_nt_acl */
 
629
        NULL,                           /* fset_nt_acl */
 
630
        NULL,                           /* set_nt_acl */
 
631
 
 
632
        NULL,                           /* chmod_acl */
 
633
        NULL,                           /* fchmod_acl */
 
634
 
 
635
        NULL,                           /* sys_acl_get_entry */
 
636
        NULL,                           /* sys_acl_get_tag_type */
 
637
        NULL,                           /* sys_acl_get_permset */
 
638
        NULL,                           /* sys_acl_get_qualifier */
 
639
        NULL,                           /* sys_acl_get_file */
 
640
        NULL,                           /* sys_acl_get_fd */
 
641
        NULL,                           /* sys_acl_clear_perms */
 
642
        NULL,                           /* sys_acl_add_perm */
 
643
        NULL,                           /* sys_acl_to_text */
 
644
        NULL,                           /* sys_acl_init */
 
645
        NULL,                           /* sys_acl_create_entry */
 
646
        NULL,                           /* sys_acl_set_tag_type */
 
647
        NULL,                           /* sys_acl_set_qualifier */
 
648
        NULL,                           /* sys_acl_set_permset */
 
649
        NULL,                           /* sys_acl_valid */
 
650
        NULL,                           /* sys_acl_set_file */
 
651
        NULL,                           /* sys_acl_set_fd */
 
652
        NULL,                           /* sys_acl_delete_def_file */
 
653
        NULL,                           /* sys_acl_get_perm */
 
654
        NULL,                           /* sys_acl_free_text */
 
655
        NULL,                           /* sys_acl_free_acl */
 
656
        NULL                            /* sys_acl_free_qualifier */
 
657
};
 
658
</programlisting>
 
659
-&gt;
 
660
<programlisting> 
 
661
static vfs_op_tuple example_op_tuples[] = {
 
662
        {SMB_VFS_OP(example_connect),   SMB_VFS_OP_CONNECT,     SMB_VFS_LAYER_TRANSPARENT},
 
663
        {SMB_VFS_OP(example_disconnect),        SMB_VFS_OP_DISCONNECT,  SMB_VFS_LAYER_TRANSPARENT},
 
664
        
 
665
        {SMB_VFS_OP(example_fstat),     SMB_VFS_OP_FSTAT,       SMB_VFS_LAYER_TRANSPARENT},
 
666
        {SMB_VFS_OP(example_stat),              SMB_VFS_OP_STAT,        SMB_VFS_LAYER_TRANSPARENT},
 
667
        {SMB_VFS_OP(example_lstat),     SMB_VFS_OP_LSTAT,       SMB_VFS_LAYER_TRANSPARENT},
 
668
 
 
669
        {SMB_VFS_OP(NULL),                              SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
 
670
};
 
671
</programlisting>
 
672
</para></listitem>
 
673
 
 
674
<listitem><para>
 
675
Move the example_op_tuples[] array to the end of the file. 
 
676
</para></listitem>
 
677
 
 
678
<listitem><para>
 
679
Add the init_module() function at the end of the file.
 
680
e.g.
 
681
<programlisting>
 
682
NTSTATUS init_module(void)
 
683
{
 
684
        return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,&quot;example&quot;,example_op_tuples);
 
685
}
 
686
</programlisting>
 
687
</para></listitem>
 
688
 
 
689
<listitem><para>
 
690
Check if your vfs_init() function does more then just prepare the vfs_ops structs or
 
691
remember the struct smb_vfs_handle_struct.
 
692
<simplelist>
 
693
<member>If NOT you can remove the vfs_init() function.</member>
 
694
<member>If YES decide if you want to move the code to the example_connect() operation or to the init_module(). And then remove vfs_init().
 
695
  e.g. a debug class registration should go into init_module() and the allocation of private data should go to example_connect().</member>
 
696
</simplelist>
 
697
</para></listitem>
 
698
 
 
699
<listitem><para>
 
700
(Only for 3.0alpha* modules) 
 
701
Check if your vfs_done() function contains needed code.
 
702
<simplelist>
 
703
<member>If NOT you can remove the vfs_done() function.</member>
 
704
<member>If YES decide if you can move the code to the example_disconnect() operation. Otherwise register a SMB_EXIT_EVENT with smb_register_exit_event(); (Described in the <link linkend="modules">modules section</link>) And then remove vfs_done(). e.g. the freeing of private data should go to example_disconnect().
 
705
</member>
 
706
</simplelist>
 
707
</para></listitem>
 
708
 
 
709
<listitem><para>
 
710
Check if you have any global variables left.
 
711
Decide if it wouldn't be better to have this data on a connection basis.
 
712
<simplelist>
 
713
  <member>If NOT leave them as they are. (e.g. this could be the variable for the private debug class.)</member>
 
714
  <member>If YES pack all this data into a struct. You can use handle-&gt;data to point to such a struct on a per connection basis.</member>
 
715
</simplelist>
 
716
 
 
717
  e.g. if you have such a struct:
 
718
<programlisting>    
 
719
struct example_privates {
 
720
        char *some_string;
 
721
        int db_connection;
 
722
};
 
723
</programlisting>       
 
724
first way of doing it:
 
725
<programlisting>
 
726
static int example_connect(vfs_handle_struct *handle,
 
727
        connection_struct *conn, const char *service, 
 
728
        const char* user)
 
729
{
 
730
        struct example_privates *data = NULL;
 
731
 
 
732
        /* alloc our private data */
 
733
        data = (struct example_privates *)talloc_zero(conn-&gt;mem_ctx, sizeof(struct example_privates));
 
734
        if (!data) {
 
735
                DEBUG(0,(&quot;talloc_zero() failed\n&quot;));
 
736
                return -1;
 
737
        }
 
738
 
 
739
        /* init out private data */
 
740
        data-&gt;some_string = talloc_strdup(conn-&gt;mem_ctx,&quot;test&quot;);
 
741
        if (!data-&gt;some_string) {
 
742
                DEBUG(0,(&quot;talloc_strdup() failed\n&quot;));
 
743
                return -1;
 
744
        }
 
745
 
 
746
        data-&gt;db_connection = open_db_conn();
 
747
 
 
748
        /* and now store the private data pointer in handle-&gt;data
 
749
         * we don't need to specify a free_function here because
 
750
         * we use the connection TALLOC context.
 
751
         * (return -1 if something failed.)
 
752
         */
 
753
        VFS_HANDLE_SET_DATA(handle, data, NULL, struct example_privates, return -1);
 
754
 
 
755
        return SMB_VFS_NEXT_CONNECT(handle,conn,service,user);
 
756
}
 
757
 
 
758
static int example_close(vfs_handle_struct *handle, files_struct *fsp, int fd)
 
759
{
 
760
        struct example_privates *data = NULL;
 
761
        
 
762
        /* get the pointer to our private data
 
763
         * return -1 if something failed
 
764
         */
 
765
        SMB_VFS_HANDLE_GET_DATA(handle, data, struct example_privates, return -1);
 
766
        
 
767
        /* do something here...*/
 
768
        DEBUG(0,(&quot;some_string: %s\n&quot;,data-&gt;some_string));
 
769
        
 
770
        return SMB_VFS_NEXT_CLOSE(handle, fsp, fd);
 
771
}
 
772
</programlisting>
 
773
second way of doing it:
 
774
<programlisting>
 
775
static void free_example_privates(void **datap)
 
776
{
 
777
        struct example_privates *data = (struct example_privates *)*datap;
 
778
        
 
779
        SAFE_FREE(data-&gt;some_string);
 
780
        SAFE_FREE(data);
 
781
        
 
782
        *datap = NULL;
 
783
        
 
784
        return;
 
785
}
 
786
 
 
787
static int example_connect(vfs_handle_struct *handle, 
 
788
        connection_struct *conn, const char *service, 
 
789
        const char* user)
 
790
{
 
791
        struct example_privates *data = NULL;
 
792
 
 
793
        /* alloc our private data */
 
794
        data = (struct example_privates *)malloc(sizeof(struct example_privates));
 
795
        if (!data) {
 
796
                DEBUG(0,(&quot;malloc() failed\n&quot;));
 
797
                return -1;
 
798
        }
 
799
 
 
800
        /* init out private data */
 
801
        data-&gt;some_string = strdup(&quot;test&quot;);
 
802
        if (!data-&gt;some_string) {
 
803
                DEBUG(0,(&quot;strdup() failed\n&quot;));
 
804
                return -1;
 
805
        }
 
806
 
 
807
        data-&gt;db_connection = open_db_conn();
 
808
 
 
809
        /* and now store the private data pointer in handle-&gt;data
 
810
         * we need to specify a free_function because we used malloc() and strdup().
 
811
         * (return -1 if something failed.)
 
812
         */
 
813
        SMB_VFS_HANDLE_SET_DATA(handle, data, free_example_privates, struct example_privates, return -1);
 
814
 
 
815
        return SMB_VFS_NEXT_CONNECT(handle,conn,service,user);
 
816
}
 
817
 
 
818
static int example_close(vfs_handle_struct *handle, files_struct *fsp, int fd)
 
819
{
 
820
        struct example_privates *data = NULL;
 
821
        
 
822
        /* get the pointer to our private data
 
823
         * return -1 if something failed
 
824
         */
 
825
        SMB_VFS_HANDLE_GET_DATA(handle, data, struct example_privates, return -1);
 
826
        
 
827
        /* do something here...*/
 
828
        DEBUG(0,(&quot;some_string: %s\n&quot;,data-&gt;some_string));
 
829
        
 
830
        return SMB_VFS_NEXT_CLOSE(handle, fsp, fd);
 
831
}
 
832
</programlisting>
 
833
</para></listitem>
 
834
 
 
835
<listitem><para>
 
836
To make it easy to build 3rd party modules it would be useful to provide
 
837
configure.in, (configure), install.sh and Makefile.in with the module.
 
838
(Take a look at the example in <filename>examples/VFS</filename>.)
 
839
</para>
 
840
 
 
841
<para>
 
842
The configure script accepts <option>--with-samba-source</option> to specify 
 
843
the path to the samba source tree.
 
844
It also accept <option>--enable-developer</option> which lets the compiler 
 
845
give you more warnings.  
 
846
</para>
 
847
 
 
848
<para>
 
849
The idea is that you can extend this 
 
850
<filename>configure.in</filename> and <filename>Makefile.in</filename> scripts
 
851
for your module.
 
852
</para></listitem>
 
853
 
 
854
<listitem><para>
 
855
Compiling &amp; Testing...
 
856
<simplelist>
 
857
<member><userinput>./configure <option>--enable-developer</option></userinput> ...</member>
 
858
<member><userinput>make</userinput></member>
 
859
<member>Try to fix all compiler warnings</member>
 
860
<member><userinput>make</userinput></member>
 
861
<member>Testing, Testing, Testing ...</member>
 
862
</simplelist>
 
863
</para></listitem>
 
864
</orderedlist>
 
865
</sect2>
 
866
 
 
867
</sect1>
 
868
 
 
869
<sect1>
 
870
<title>Some Notes</title>
 
871
 
 
872
<sect2>
 
873
<title>Implement TRANSPARENT functions</title>
 
874
 
 
875
<para>
 
876
Avoid writing functions like this:
 
877
 
 
878
<programlisting>
 
879
static int example_close(vfs_handle_struct *handle, files_struct *fsp, int fd)
 
880
{
 
881
        return SMB_VFS_NEXT_CLOSE(handle, fsp, fd);
 
882
}
 
883
</programlisting>
 
884
 
 
885
Overload only the functions you really need to!
 
886
</para>
 
887
 
 
888
</sect2>
 
889
 
 
890
<sect2>
 
891
<title>Implement OPAQUE functions</title>
 
892
 
 
893
<para>
 
894
If you want to just implement a better version of a 
 
895
default samba opaque function
 
896
(e.g. like a disk_free() function for a special filesystem) 
 
897
it's ok to just overload that specific function.
 
898
</para>
 
899
 
 
900
<para>
 
901
If you want to implement a database filesystem or
 
902
something different from a posix filesystem.
 
903
Make sure that you overload every vfs operation!!!
 
904
</para>
 
905
<para>
 
906
Functions your FS does not support should be overloaded by something like this:
 
907
e.g. for a readonly filesystem.
 
908
</para>
 
909
 
 
910
<programlisting>
 
911
static int example_rename(vfs_handle_struct *handle, connection_struct *conn,
 
912
                        char *oldname, char *newname)
 
913
{
 
914
        DEBUG(10,(&quot;function rename() not allowed on vfs 'example'\n&quot;));
 
915
        errno = ENOSYS;
 
916
        return -1;
 
917
}
 
918
</programlisting>
 
919
 
 
920
</sect2>
 
921
 
 
922
</sect1>
 
923
 
 
924
</chapter>