source: trunk/samba/source/modules/vfs_gpfs.c @ 30

Last change on this file since 30 was 30, checked in by Paul Smedley, 14 years ago

Code updated to Samba 3.0.25rc2 level

File size: 17.0 KB
Line 
1/*
2   Unix SMB/CIFS implementation.
3   Wrap gpfs calls in vfs functions.
4 
5   Copyright (C) Christian Ambach <cambach1@de.ibm.com> 2006
6   
7   Major code contributions by Chetan Shringarpure <chetan.sh@in.ibm.com>
8                            and Gomati Mohanan <gomati.mohanan@in.ibm.com>
9   
10   This program is free software; you can redistribute it and/or modify
11   it under the terms of the GNU General Public License as published by
12   the Free Software Foundation; either version 2 of the License, or
13   (at your option) any later version.
14   
15   This program is distributed in the hope that it will be useful,
16   but WITHOUT ANY WARRANTY; without even the implied warranty of
17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18   GNU General Public License for more details.
19   
20   You should have received a copy of the GNU General Public License
21   along with this program; if not, write to the Free Software
22   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 
24
25*/
26
27#include "includes.h"
28
29#undef DBGC_CLASS
30#define DBGC_CLASS DBGC_VFS
31
32#include <gpfs_gpl.h>
33#include "nfs4_acls.h"
34
35
36static int vfs_gpfs_kernel_flock(vfs_handle_struct *handle, files_struct *fsp, 
37                                 int fd, uint32 share_mode)
38{
39
40        START_PROFILE(syscall_kernel_flock);
41
42        kernel_flock(fsp->fh->fd, share_mode);
43
44        if (!set_gpfs_sharemode(fsp, fsp->access_mask, fsp->share_access)) {
45
46                return -1;
47
48        }
49
50        END_PROFILE(syscall_kernel_flock);
51
52        return 0;
53}
54
55static int vfs_gpfs_setlease(vfs_handle_struct *handle, files_struct *fsp, 
56                                 int fd, int leasetype)
57{
58        int ret;
59       
60        START_PROFILE(syscall_linux_setlease);
61       
62        if ( linux_set_lease_sighandler(fd) == -1)
63                return -1;
64
65        ret = set_gpfs_lease(fd,leasetype);
66       
67        if ( ret < 0 ) {
68                /* This must have come from GPFS not being available */
69                /* or some other error, hence call the default */
70                ret = linux_setlease(fd, leasetype);
71        }
72
73        END_PROFILE(syscall_linux_setlease);
74
75        return ret;
76}
77
78
79
80static void gpfs_dumpacl(int level, struct gpfs_acl *gacl)
81{
82        int     i;
83        if (gacl==NULL)
84        {
85                DEBUG(0, ("gpfs acl is NULL\n"));
86                return;
87        }
88
89        DEBUG(level, ("gpfs acl: nace: %d, type:%d, version:%d, level:%d, len:%d\n",
90                gacl->acl_nace, gacl->acl_type, gacl->acl_version, gacl->acl_level, gacl->acl_len));
91        for(i=0; i<gacl->acl_nace; i++)
92        {
93                struct gpfs_ace_v4 *gace = gacl->ace_v4 + i;
94                DEBUG(level, ("\tace[%d]: type:%d, flags:0x%x, mask:0x%x, iflags:0x%x, who:%u\n",
95                        i, gace->aceType, gace->aceFlags, gace->aceMask,
96                        gace->aceIFlags, gace->aceWho));
97        }
98}
99
100static struct gpfs_acl *gpfs_getacl_alloc(const char *fname, gpfs_aclType_t type)
101{
102        struct gpfs_acl *acl;
103        size_t len = 200;
104        int ret;
105        TALLOC_CTX *mem_ctx = main_loop_talloc_get();
106
107        acl = (struct gpfs_acl *)talloc_size(mem_ctx, len);
108        if (acl == NULL) {
109                errno = ENOMEM;
110                return NULL;
111        }
112
113        acl->acl_len = len;
114        acl->acl_level = 0;
115        acl->acl_version = 0;
116        acl->acl_type = type;
117
118        ret = smbd_gpfs_getacl((char *)fname, GPFS_GETACL_STRUCT | GPFS_ACL_SAMBA, acl);
119        if ((ret != 0) && (errno == ENOSPC)) {
120                struct gpfs_acl *new_acl = (struct gpfs_acl *)talloc_size(
121                        mem_ctx, acl->acl_len + sizeof(struct gpfs_acl));
122                if (new_acl == NULL) {
123                        errno = ENOMEM;
124                        return NULL;
125                }
126
127                new_acl->acl_len = acl->acl_len;
128                new_acl->acl_level = acl->acl_level;
129                new_acl->acl_version = acl->acl_version;
130                new_acl->acl_type = acl->acl_type;
131                acl = new_acl;
132
133                ret = smbd_gpfs_getacl((char *)fname, GPFS_GETACL_STRUCT | GPFS_ACL_SAMBA, acl);
134        }
135        if (ret != 0)
136        {
137                DEBUG(8, ("smbd_gpfs_getacl failed with %s\n",strerror(errno)));
138                return NULL;
139        }
140
141        return acl;
142}
143
144static BOOL gpfs_get_nfs4_acl(struct files_struct *fsp, SMB4ACL_T **ppacl, BOOL *pretryPosix)
145{
146        TALLOC_CTX *mem_ctx;
147        int i;
148        struct gpfs_acl *gacl = NULL;
149
150        mem_ctx = main_loop_talloc_get();
151
152        DEBUG(10, ("gpfs_get_nfs4_acl invoked for %s\n", fsp->fsp_name));
153
154        /* First get the real acl length */
155        gacl = gpfs_getacl_alloc(fsp->fsp_name, GPFS_ACL_TYPE_NFS4);
156        if (gacl == NULL) {
157                DEBUG(9, ("gpfs_getacl failed for %s with %s\n",
158                           fsp->fsp_name, strerror(errno)));
159                return False;
160        }
161
162        if (gacl->acl_type != GPFS_ACL_TYPE_NFS4) {
163                DEBUG(10, ("Got non-nfsv4 acl\n"));
164                *pretryPosix = True;
165                return False;
166        }
167
168        *ppacl = smb_create_smb4acl();
169
170        DEBUG(10, ("len: %d, level: %d, version: %d, nace: %d\n",
171                   gacl->acl_len, gacl->acl_level, gacl->acl_version,
172                   gacl->acl_nace));
173
174        for (i=0; i<gacl->acl_nace; i++) {
175                struct gpfs_ace_v4 *gace = &gacl->ace_v4[i];
176                SMB_ACE4PROP_T smbace;
177                memset(&smbace, 0, sizeof(SMB4ACE_T));
178
179                DEBUG(10, ("type: %d, iflags: %x, flags: %x, mask: %x, "
180                           "who: %d\n", gace->aceType, gace->aceIFlags,
181                           gace->aceFlags, gace->aceMask, gace->aceWho));
182
183                if (gace->aceIFlags & ACE4_IFLAG_SPECIAL_ID) {
184                        smbace.flags |= SMB_ACE4_ID_SPECIAL;
185                        switch (gace->aceWho) {
186                        case ACE4_SPECIAL_OWNER:
187                                smbace.who.special_id = SMB_ACE4_WHO_OWNER;
188                                break;
189                        case ACE4_SPECIAL_GROUP:
190                                smbace.who.special_id = SMB_ACE4_WHO_GROUP;
191                                break;
192                        case ACE4_SPECIAL_EVERYONE:
193                                smbace.who.special_id = SMB_ACE4_WHO_EVERYONE;
194                                break;
195                        default:
196                                DEBUG(8, ("invalid special gpfs id %d "
197                                          "ignored\n", gace->aceWho));
198                                continue; /* don't add it */
199                        }
200                } else {
201                        if (gace->aceFlags & ACE4_FLAG_GROUP_ID)
202                                smbace.who.gid = gace->aceWho;
203                        else
204                                smbace.who.uid = gace->aceWho;
205                }
206
207                smbace.aceType = gace->aceType;
208                smbace.aceFlags = gace->aceFlags;
209                smbace.aceMask = gace->aceMask;
210                smbace.flags = (gace->aceIFlags&ACE4_IFLAG_SPECIAL_ID) ? SMB_ACE4_ID_SPECIAL : 0;
211
212                smb_add_ace4(*ppacl, &smbace);
213        }
214
215        return True;
216}
217
218static size_t gpfsacl_get_nt_acl_common(files_struct *fsp,
219        uint32 security_info, SEC_DESC **ppdesc)
220{
221        SMB4ACL_T *pacl = NULL;
222        BOOL    result;
223        BOOL    retryPosix = False;
224
225        *ppdesc = NULL;
226        result = gpfs_get_nfs4_acl(fsp, &pacl, &retryPosix);
227        if (retryPosix)
228        {
229                DEBUG(10, ("retrying with posix acl...\n"));
230                return get_nt_acl(fsp, security_info, ppdesc);
231        }
232        if (result==False)
233                return 0;
234
235        return smb_get_nt_acl_nfs4(fsp, security_info, ppdesc, pacl);
236}
237
238size_t gpfsacl_fget_nt_acl(vfs_handle_struct *handle,
239        files_struct *fsp, int fd, uint32 security_info,
240        SEC_DESC **ppdesc)
241{
242        return gpfsacl_get_nt_acl_common(fsp, security_info, ppdesc);
243}
244
245size_t gpfsacl_get_nt_acl(vfs_handle_struct *handle,
246        files_struct *fsp, const char *name,
247        uint32 security_info, SEC_DESC **ppdesc)
248{
249        return gpfsacl_get_nt_acl_common(fsp, security_info, ppdesc);
250}
251
252static BOOL gpfsacl_process_smbacl(files_struct *fsp, SMB4ACL_T *smbacl)
253{
254        int ret;
255        gpfs_aclLen_t gacl_len;
256        SMB4ACE_T       *smbace;
257        struct gpfs_acl *gacl;
258        TALLOC_CTX *mem_ctx  = main_loop_talloc_get();
259
260        gacl_len = sizeof(struct gpfs_acl) +
261                (smb_get_naces(smbacl)-1)*sizeof(gpfs_ace_v4_t);
262
263        gacl = talloc_size(mem_ctx, gacl_len);
264        if (gacl == NULL) {
265                DEBUG(0, ("talloc failed\n"));
266                errno = ENOMEM;
267                return False;
268        }
269
270        gacl->acl_len = gacl_len;
271        gacl->acl_level = 0;
272        gacl->acl_version = GPFS_ACL_VERSION_NFS4;
273        gacl->acl_type = GPFS_ACL_TYPE_NFS4;
274        gacl->acl_nace = 0; /* change later... */
275
276        for (smbace=smb_first_ace4(smbacl); smbace!=NULL; smbace = smb_next_ace4(smbace)) {
277                struct gpfs_ace_v4 *gace = &gacl->ace_v4[gacl->acl_nace];
278                SMB_ACE4PROP_T  *aceprop = smb_get_ace4(smbace);
279
280                gace->aceType = aceprop->aceType;
281                gace->aceFlags = aceprop->aceFlags;
282                gace->aceMask = aceprop->aceMask;
283                gace->aceIFlags = (aceprop->flags&SMB_ACE4_ID_SPECIAL) ? ACE4_IFLAG_SPECIAL_ID : 0;
284
285                if (aceprop->flags&SMB_ACE4_ID_SPECIAL)
286                {
287                        switch(aceprop->who.special_id)
288                        {
289                        case SMB_ACE4_WHO_EVERYONE:
290                                gace->aceWho = ACE4_SPECIAL_EVERYONE;
291                                break;
292                        case SMB_ACE4_WHO_OWNER:
293                                gace->aceWho = ACE4_SPECIAL_OWNER;
294                                break;
295                        case SMB_ACE4_WHO_GROUP:
296                                gace->aceWho = ACE4_SPECIAL_GROUP;
297                                break;
298                        default:
299                                DEBUG(8, ("unsupported special_id %d\n", aceprop->who.special_id));
300                                continue; /* don't add it !!! */
301                        }
302                } else {
303                        /* just only for the type safety... */
304                        if (aceprop->aceFlags&SMB_ACE4_IDENTIFIER_GROUP)
305                                gace->aceWho = aceprop->who.gid;
306                        else
307                                gace->aceWho = aceprop->who.uid;
308                }
309
310                gacl->acl_nace++;
311        }
312
313        ret = smbd_gpfs_putacl(fsp->fsp_name, GPFS_PUTACL_STRUCT | GPFS_ACL_SAMBA, gacl);
314        if (ret != 0) {
315                DEBUG(8, ("gpfs_putacl failed with %s\n", strerror(errno)));
316                gpfs_dumpacl(8, gacl);
317                return False;
318        }
319
320        DEBUG(10, ("gpfs_putacl succeeded\n"));
321        return True;
322}
323
324static BOOL gpfsacl_set_nt_acl_internal(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
325{
326        struct gpfs_acl *acl;
327        BOOL    result = False;
328
329        acl = gpfs_getacl_alloc(fsp->fsp_name, GPFS_ACL_TYPE_ACCESS);
330        if (acl == NULL)
331                return False;
332
333        if (acl->acl_version&GPFS_ACL_VERSION_NFS4)
334        {
335                result = smb_set_nt_acl_nfs4(
336                        fsp, security_info_sent, psd,
337                        gpfsacl_process_smbacl);
338        } else { /* assume POSIX ACL - by default... */
339                result = set_nt_acl(fsp, security_info_sent, psd);
340        }
341
342        return result;
343}
344
345static BOOL gpfsacl_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 security_info_sent, SEC_DESC *psd)
346{
347        return gpfsacl_set_nt_acl_internal(fsp, security_info_sent, psd);
348}
349
350static BOOL gpfsacl_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp, char *name, uint32 security_info_sent, SEC_DESC *psd)
351{
352        return gpfsacl_set_nt_acl_internal(fsp, security_info_sent, psd);
353}
354
355static SMB_ACL_T gpfs2smb_acl(const struct gpfs_acl *pacl)
356{
357        SMB_ACL_T result;
358        int i;
359
360        result = sys_acl_init(pacl->acl_nace);
361        if (result == NULL) {
362                errno = ENOMEM;
363                return NULL;
364        }
365
366        result->count = pacl->acl_nace;
367
368        for (i=0; i<pacl->acl_nace; i++) {
369                struct smb_acl_entry *ace = &result->acl[i];
370                const struct gpfs_ace_v1 *g_ace = &pacl->ace_v1[i];
371
372                DEBUG(10, ("Converting type %d id %lu perm %x\n",
373                           (int)g_ace->ace_type, (unsigned long)g_ace->ace_who,
374                           (int)g_ace->ace_perm));
375
376                switch (g_ace->ace_type) {
377                case GPFS_ACL_USER:
378                        ace->a_type = SMB_ACL_USER;
379                        ace->uid = (uid_t)g_ace->ace_who;
380                        break;
381                case GPFS_ACL_USER_OBJ:
382                        ace->a_type = SMB_ACL_USER_OBJ;
383                        break;
384                case GPFS_ACL_GROUP:
385                        ace->a_type = SMB_ACL_GROUP;
386                        ace->gid = (gid_t)g_ace->ace_who;
387                        break;
388                case GPFS_ACL_GROUP_OBJ:
389                        ace->a_type = SMB_ACL_GROUP_OBJ;
390                        break;
391                case GPFS_ACL_OTHER:
392                        ace->a_type = SMB_ACL_OTHER;
393                        break;
394                case GPFS_ACL_MASK:
395                        ace->a_type = SMB_ACL_MASK;
396                        break;
397                default:
398                        DEBUG(10, ("Got invalid ace_type: %d\n",
399                                   g_ace->ace_type));
400                        errno = EINVAL;
401                        SAFE_FREE(result);
402                        return NULL;
403                }
404
405                ace->a_perm = 0;
406                ace->a_perm |= (g_ace->ace_perm & ACL_PERM_READ) ?
407                        SMB_ACL_READ : 0;
408                ace->a_perm |= (g_ace->ace_perm & ACL_PERM_WRITE) ?
409                        SMB_ACL_WRITE : 0;
410                ace->a_perm |= (g_ace->ace_perm & ACL_PERM_EXECUTE) ?
411                        SMB_ACL_EXECUTE : 0;
412
413                DEBUGADD(10, ("Converted to %d perm %x\n",
414                              ace->a_type, ace->a_perm));
415        }
416
417        return result;
418}
419
420static SMB_ACL_T gpfsacl_get_posix_acl(const char *path, gpfs_aclType_t type)
421{
422        struct gpfs_acl *pacl;
423        SMB_ACL_T result = NULL;
424
425        pacl = gpfs_getacl_alloc(path, type);
426
427        if (pacl == NULL) {
428                DEBUG(10, ("gpfs_getacl failed for %s with %s\n",
429                           path, strerror(errno)));
430                if (errno == 0) {
431                        errno = EINVAL;
432                }
433                goto done;
434        }
435
436        if (pacl->acl_version != GPFS_ACL_VERSION_POSIX) {
437                DEBUG(10, ("Got acl version %d, expected %d\n",
438                           pacl->acl_version, GPFS_ACL_VERSION_POSIX));
439                errno = EINVAL;
440                goto done;
441        }
442       
443        DEBUG(10, ("len: %d, level: %d, version: %d, nace: %d\n",
444                   pacl->acl_len, pacl->acl_level, pacl->acl_version,
445                   pacl->acl_nace));
446
447        result = gpfs2smb_acl(pacl);
448        if (result == NULL) {
449                goto done;
450        }
451
452 done:
453
454        if (errno != 0) {
455                SAFE_FREE(result);
456        }
457        return result; 
458}
459
460SMB_ACL_T gpfsacl_sys_acl_get_file(vfs_handle_struct *handle,
461                                   
462                                    const char *path_p,
463                                    SMB_ACL_TYPE_T type)
464{
465        gpfs_aclType_t gpfs_type;
466
467        switch(type) {
468        case SMB_ACL_TYPE_ACCESS:
469                gpfs_type = GPFS_ACL_TYPE_ACCESS;
470                break;
471        case SMB_ACL_TYPE_DEFAULT:
472                gpfs_type = GPFS_ACL_TYPE_DEFAULT;
473                break;
474        default:
475                DEBUG(0, ("Got invalid type: %d\n", type));
476                smb_panic("exiting");
477        }
478
479        return gpfsacl_get_posix_acl(path_p, gpfs_type);
480}
481
482SMB_ACL_T gpfsacl_sys_acl_get_fd(vfs_handle_struct *handle,
483                                  files_struct *fsp,
484                                  int fd)
485{
486        return gpfsacl_get_posix_acl(fsp->fsp_name, GPFS_ACL_TYPE_ACCESS);
487}
488
489static struct gpfs_acl *smb2gpfs_acl(const SMB_ACL_T pacl,
490                                     SMB_ACL_TYPE_T type)
491{
492        gpfs_aclLen_t len;
493        struct gpfs_acl *result;
494        int i;
495        union gpfs_ace_union
496        {
497                gpfs_ace_v1_t  ace_v1[1]; /* when GPFS_ACL_VERSION_POSIX */
498                gpfs_ace_v4_t  ace_v4[1]; /* when GPFS_ACL_VERSION_NFS4  */
499        };
500
501        DEBUG(10, ("smb2gpfs_acl: Got ACL with %d entries\n", pacl->count));
502
503        len = sizeof(struct gpfs_acl) - sizeof(union gpfs_ace_union) +
504                (pacl->count)*sizeof(gpfs_ace_v1_t);
505
506        result = SMB_MALLOC(len);
507        if (result == NULL) {
508                errno = ENOMEM;
509                return result;
510        }
511
512        result->acl_len = len;
513        result->acl_level = 0;
514        result->acl_version = GPFS_ACL_VERSION_POSIX;
515        result->acl_type = (type == SMB_ACL_TYPE_DEFAULT) ?
516                GPFS_ACL_TYPE_DEFAULT : GPFS_ACL_TYPE_ACCESS;
517        result->acl_nace = pacl->count;
518
519        for (i=0; i<pacl->count; i++) {
520                const struct smb_acl_entry *ace = &pacl->acl[i];
521                struct gpfs_ace_v1 *g_ace = &result->ace_v1[i];
522               
523                DEBUG(10, ("Converting type %d perm %x\n",
524                           (int)ace->a_type, (int)ace->a_perm));
525
526                g_ace->ace_perm = 0;
527
528                switch(ace->a_type) {
529                case SMB_ACL_USER:
530                        g_ace->ace_type = GPFS_ACL_USER;
531                        g_ace->ace_who = (gpfs_uid_t)ace->uid;
532                        break;
533                case SMB_ACL_USER_OBJ:
534                        g_ace->ace_type = GPFS_ACL_USER_OBJ;
535                        g_ace->ace_perm |= ACL_PERM_CONTROL;
536                        g_ace->ace_who = 0;
537                        break;
538                case SMB_ACL_GROUP:
539                        g_ace->ace_type = GPFS_ACL_GROUP;
540                        g_ace->ace_who = (gpfs_uid_t)ace->gid;
541                        break;
542                case SMB_ACL_GROUP_OBJ:
543                        g_ace->ace_type = GPFS_ACL_GROUP_OBJ;
544                        g_ace->ace_who = 0;
545                        break;
546                case SMB_ACL_MASK:
547                        g_ace->ace_type = GPFS_ACL_MASK;
548                        g_ace->ace_perm = 0x8f;
549                        g_ace->ace_who = 0;
550                        break;
551                case SMB_ACL_OTHER:
552                        g_ace->ace_type = GPFS_ACL_OTHER;
553                        g_ace->ace_who = 0;
554                        break;
555                default:
556                        DEBUG(10, ("Got invalid ace_type: %d\n", ace->a_type));
557                        errno = EINVAL;
558                        SAFE_FREE(result);
559                        return NULL;
560                }
561
562                g_ace->ace_perm |= (ace->a_perm & SMB_ACL_READ) ?
563                        ACL_PERM_READ : 0;
564                g_ace->ace_perm |= (ace->a_perm & SMB_ACL_WRITE) ?
565                        ACL_PERM_WRITE : 0;
566                g_ace->ace_perm |= (ace->a_perm & SMB_ACL_EXECUTE) ?
567                        ACL_PERM_EXECUTE : 0;
568
569                DEBUGADD(10, ("Converted to %d id %d perm %x\n",
570                              g_ace->ace_type, g_ace->ace_who, g_ace->ace_perm));
571        }
572
573        return result;
574}
575
576int gpfsacl_sys_acl_set_file(vfs_handle_struct *handle,
577                             
578                              const char *name,
579                              SMB_ACL_TYPE_T type,
580                              SMB_ACL_T theacl)
581{
582        struct gpfs_acl *gpfs_acl;
583        int result;
584
585        gpfs_acl = smb2gpfs_acl(theacl, type);
586        if (gpfs_acl == NULL) {
587                return -1;
588        }
589
590        result = smbd_gpfs_putacl((char *)name, GPFS_PUTACL_STRUCT | GPFS_ACL_SAMBA, gpfs_acl);
591
592        SAFE_FREE(gpfs_acl);
593        return result;
594}
595
596int gpfsacl_sys_acl_set_fd(vfs_handle_struct *handle,
597                            files_struct *fsp,
598                            int fd, SMB_ACL_T theacl)
599{
600        return gpfsacl_sys_acl_set_file(handle, fsp->fsp_name, SMB_ACL_TYPE_ACCESS, theacl);
601}
602
603int gpfsacl_sys_acl_delete_def_file(vfs_handle_struct *handle,
604                                     
605                                     const char *path)
606{
607        errno = ENOTSUP;
608        return -1;
609}
610
611/* VFS operations structure */
612
613static vfs_op_tuple gpfs_op_tuples[] = {
614
615        {SMB_VFS_OP(vfs_gpfs_kernel_flock),
616         SMB_VFS_OP_KERNEL_FLOCK,
617         SMB_VFS_LAYER_OPAQUE},
618
619        {SMB_VFS_OP(vfs_gpfs_setlease),
620         SMB_VFS_OP_LINUX_SETLEASE,
621         SMB_VFS_LAYER_OPAQUE},
622
623        {SMB_VFS_OP(gpfsacl_fget_nt_acl),
624        SMB_VFS_OP_FGET_NT_ACL,
625        SMB_VFS_LAYER_TRANSPARENT},
626
627        {SMB_VFS_OP(gpfsacl_get_nt_acl),
628        SMB_VFS_OP_GET_NT_ACL,
629        SMB_VFS_LAYER_TRANSPARENT},
630
631        {SMB_VFS_OP(gpfsacl_fset_nt_acl),
632        SMB_VFS_OP_FSET_NT_ACL,
633        SMB_VFS_LAYER_TRANSPARENT},
634
635        {SMB_VFS_OP(gpfsacl_set_nt_acl),
636        SMB_VFS_OP_SET_NT_ACL,
637        SMB_VFS_LAYER_TRANSPARENT},
638
639        {SMB_VFS_OP(gpfsacl_sys_acl_get_file),
640         SMB_VFS_OP_SYS_ACL_GET_FILE,
641         SMB_VFS_LAYER_TRANSPARENT},
642
643        {SMB_VFS_OP(gpfsacl_sys_acl_get_fd),
644         SMB_VFS_OP_SYS_ACL_GET_FD,
645         SMB_VFS_LAYER_TRANSPARENT},
646
647        {SMB_VFS_OP(gpfsacl_sys_acl_set_file),
648         SMB_VFS_OP_SYS_ACL_SET_FILE,
649         SMB_VFS_LAYER_TRANSPARENT},
650
651        {SMB_VFS_OP(gpfsacl_sys_acl_set_fd),
652         SMB_VFS_OP_SYS_ACL_SET_FD,
653         SMB_VFS_LAYER_TRANSPARENT},
654
655        {SMB_VFS_OP(gpfsacl_sys_acl_delete_def_file),
656         SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
657         SMB_VFS_LAYER_TRANSPARENT},
658
659        {SMB_VFS_OP(NULL),
660         SMB_VFS_OP_NOOP,
661         SMB_VFS_LAYER_NOOP}
662
663};
664
665
666NTSTATUS vfs_gpfs_init(void);
667NTSTATUS vfs_gpfs_init(void)
668{
669        init_gpfs();
670       
671        return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "gpfs",
672                                gpfs_op_tuples);
673}
Note: See TracBrowser for help on using the repository browser.