?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: smbd: Make extract_snapshot_token() a wrapper for extract_snapshot_token_internal().
[Samba.git] / source3 / modules / vfs_fileid.c
blob2c67946efb3fdb52dbffd08581c9d70c96c8293f
1 /*
2 * VFS module to alter the algorithm to calculate
3 * the struct file_id used as key for the share mode
4 * and byte range locking db's.
5 *
6 * Copyright (C) 2007, Stefan Metzmacher
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "smbd/smbd.h"
24 #include "system/filesys.h"
25
26 static int vfs_fileid_debug_level = DBGC_VFS;
27
28 #undef DBGC_CLASS
29 #define DBGC_CLASS vfs_fileid_debug_level
30
31 struct fileid_mount_entry {
32 SMB_DEV_T device;
33 const char *mnt_fsname;
34 fsid_t fsid;
35 uint64_t devid;
36 };
37
38 struct fileid_nolock_inode {
39 dev_t dev;
40 ino_t ino;
41 };
42
43 struct fileid_handle_data {
44 struct vfs_handle_struct *handle;
45 struct file_id (*mapping_fn)(struct fileid_handle_data *data,
46 const SMB_STRUCT_STAT *sbuf);
47 char **fstype_deny_list;
48 char **fstype_allow_list;
49 char **mntdir_deny_list;
50 char **mntdir_allow_list;
51 unsigned num_mount_entries;
52 struct fileid_mount_entry *mount_entries;
53 struct {
54 bool force_all_inodes;
55 bool force_all_dirs;
56 uint64_t extid;
57 size_t num_inodes;
58 struct fileid_nolock_inode *inodes;
59 } nolock;
60 };
61
62 /* check if a mount entry is allowed based on fstype and mount directory */
63 static bool fileid_mount_entry_allowed(struct fileid_handle_data *data,
64 struct mntent *m)
65 {
66 int i;
67 char **fstype_deny = data->fstype_deny_list;
68 char **fstype_allow = data->fstype_allow_list;
69 char **mntdir_deny = data->mntdir_deny_list;
70 char **mntdir_allow = data->mntdir_allow_list;
71
72 if (fstype_deny != NULL) {
73 for (i = 0; fstype_deny[i] != NULL; i++) {
74 if (strcmp(m->mnt_type, fstype_deny[i]) == 0) {
75 return false;
76 }
77 }
78 }
79 if (fstype_allow != NULL) {
80 for (i = 0; fstype_allow[i] != NULL; i++) {
81 if (strcmp(m->mnt_type, fstype_allow[i]) == 0) {
82 break;
83 }
84 }
85 if (fstype_allow[i] == NULL) {
86 return false;
87 }
88 }
89 if (mntdir_deny != NULL) {
90 for (i=0; mntdir_deny[i] != NULL; i++) {
91 if (strcmp(m->mnt_dir, mntdir_deny[i]) == 0) {
92 return false;
93 }
94 }
95 }
96 if (mntdir_allow != NULL) {
97 for (i=0; mntdir_allow[i] != NULL; i++) {
98 if (strcmp(m->mnt_dir, mntdir_allow[i]) == 0) {
99 break;
100 }
101 }
102 if (mntdir_allow[i] == NULL) {
103 return false;
104 }
105 }
106 return true;
107 }
108
109
110 /* load all the mount entries from the mtab */
111 static void fileid_load_mount_entries(struct fileid_handle_data *data)
112 {
113 FILE *f;
114 struct mntent *m;
115
116 data->num_mount_entries = 0;
117 TALLOC_FREE(data->mount_entries);
118
119 f = setmntent("/etc/mtab", "r");
120 if (!f) return;
121
122 while ((m = getmntent(f))) {
123 struct stat st;
124 struct statfs sfs;
125 struct fileid_mount_entry *cur;
126 bool allowed;
127
128 allowed = fileid_mount_entry_allowed(data, m);
129 if (!allowed) {
130 DBG_DEBUG("skipping mount entry %s\n", m->mnt_dir);
131 continue;
132 }
133 if (stat(m->mnt_dir, &st) != 0) continue;
134 if (statfs(m->mnt_dir, &sfs) != 0) continue;
135
136 if (strncmp(m->mnt_fsname, "/dev/", 5) == 0) {
137 m->mnt_fsname += 5;
138 }
139
140 data->mount_entries = talloc_realloc(data,
141 data->mount_entries,
142 struct fileid_mount_entry,
143 data->num_mount_entries+1);
144 if (data->mount_entries == NULL) {
145 goto nomem;
146 }
147
148 cur = &data->mount_entries[data->num_mount_entries];
149 cur->device = st.st_dev;
150 cur->mnt_fsname = talloc_strdup(data->mount_entries,
151 m->mnt_fsname);
152 if (!cur->mnt_fsname) goto nomem;
153 cur->fsid = sfs.f_fsid;
154 cur->devid = (uint64_t)-1;
155
156 data->num_mount_entries++;
157 }
158 endmntent(f);
159 return;
160
161 nomem:
162 if (f) endmntent(f);
163
164 data->num_mount_entries = 0;
165 TALLOC_FREE(data->mount_entries);
166
167 return;
168 }
169
170 /* find a mount entry given a dev_t */
171 static struct fileid_mount_entry *fileid_find_mount_entry(struct fileid_handle_data *data,
172 SMB_DEV_T dev)
173 {
174 unsigned i;
175
176 if (data->num_mount_entries == 0) {
177 fileid_load_mount_entries(data);
178 }
179 for (i=0;i<data->num_mount_entries;i++) {
180 if (data->mount_entries[i].device == dev) {
181 return &data->mount_entries[i];
182 }
183 }
184 /* 2nd pass after reloading */
185 fileid_load_mount_entries(data);
186 for (i=0;i<data->num_mount_entries;i++) {
187 if (data->mount_entries[i].device == dev) {
188 return &data->mount_entries[i];
189 }
190 }
191 return NULL;
192 }
193
194
195 /* a 64 bit hash, based on the one in tdb */
196 static uint64_t fileid_uint64_hash(const uint8_t *s, size_t len)
197 {
198 uint64_t value; /* Used to compute the hash value. */
199 uint32_t i; /* Used to cycle through random values. */
200
201 /* Set the initial value from the key size. */
202 for (value = 0x238F13AFLL * len, i=0; i < len; i++)
203 value = (value + (((uint64_t)s[i]) << (i*5 % 24)));
204
205 return (1103515243LL * value + 12345LL);
206 }
207
208 /* a device mapping using a fsname */
209 static uint64_t fileid_device_mapping_fsname(struct fileid_handle_data *data,
210 const SMB_STRUCT_STAT *sbuf)
211 {
212 struct fileid_mount_entry *m;
213
214 m = fileid_find_mount_entry(data, sbuf->st_ex_dev);
215 if (!m) return sbuf->st_ex_dev;
216
217 if (m->devid == (uint64_t)-1) {
218 m->devid = fileid_uint64_hash((const uint8_t *)m->mnt_fsname,
219 strlen(m->mnt_fsname));
220 }
221
222 return m->devid;
223 }
224
225 static struct file_id fileid_mapping_fsname(struct fileid_handle_data *data,
226 const SMB_STRUCT_STAT *sbuf)
227 {
228 struct file_id id = { .inode = sbuf->st_ex_ino, };
229
230 id.devid = fileid_device_mapping_fsname(data, sbuf);
231
232 return id;
233 }
234
235 /* a device mapping using a hostname */
236 static uint64_t fileid_device_mapping_hostname(struct fileid_handle_data *data,
237 const SMB_STRUCT_STAT *sbuf)
238 {
239 char hostname[HOST_NAME_MAX+1];
240 char *devname = NULL;
241 uint64_t id;
242 size_t devname_len;
243 int rc;
244
245 rc = gethostname(hostname, HOST_NAME_MAX+1);
246 if (rc != 0) {
247 DBG_ERR("gethostname failed\n");
248 return UINT64_MAX;
249 }
250
251 devname = talloc_asprintf(talloc_tos(), "%s%ju",
252 hostname, (uintmax_t)sbuf->st_ex_dev);
253 if (devname == NULL) {
254 DBG_ERR("talloc_asprintf failed\n");
255 return UINT64_MAX;
256 }
257 devname_len = talloc_array_length(devname) - 1;
258
259 id = fileid_uint64_hash((uint8_t *)devname, devname_len);
260
261 TALLOC_FREE(devname);
262
263 return id;
264 }
265
266 static struct file_id fileid_mapping_hostname(struct fileid_handle_data *data,
267 const SMB_STRUCT_STAT *sbuf)
268 {
269 struct file_id id = { .inode = sbuf->st_ex_ino, };
270
271 id.devid = fileid_device_mapping_hostname(data, sbuf);
272
273 return id;
274 }
275
276 static bool fileid_is_nolock_inode(struct fileid_handle_data *data,
277 const SMB_STRUCT_STAT *sbuf)
278 {
279 size_t i;
280
281 if (data->nolock.force_all_inodes) {
282 return true;
283 }
284
285 if (S_ISDIR(sbuf->st_ex_mode) && data->nolock.force_all_dirs) {
286 return true;
287 }
288
289 /*
290 * We could make this a binary search over an sorted array,
291 * but for now we keep things simple.
292 */
293
294 for (i=0; i < data->nolock.num_inodes; i++) {
295 if (data->nolock.inodes[i].ino != sbuf->st_ex_ino) {
296 continue;
297 }
298
299 if (data->nolock.inodes[i].dev == 0) {
300 /*
301 * legacy "fileid:nolockinode"
302 * handling ignoring dev
303 */
304 return true;
305 }
306
307 if (data->nolock.inodes[i].dev != sbuf->st_ex_dev) {
308 continue;
309 }
310
311 return true;
312 }
313
314 return false;
315 }
316
317 static int fileid_add_nolock_inode(struct fileid_handle_data *data,
318 const SMB_STRUCT_STAT *sbuf)
319 {
320 bool exists = fileid_is_nolock_inode(data, sbuf);
321 struct fileid_nolock_inode *inodes = NULL;
322
323 if (exists) {
324 return 0;
325 }
326
327 inodes = talloc_realloc(data, data->nolock.inodes,
328 struct fileid_nolock_inode,
329 data->nolock.num_inodes + 1);
330 if (inodes == NULL) {
331 return -1;
332 }
333
334 inodes[data->nolock.num_inodes] = (struct fileid_nolock_inode) {
335 .dev = sbuf->st_ex_dev,
336 .ino = sbuf->st_ex_ino,
337 };
338 data->nolock.inodes = inodes;
339 data->nolock.num_inodes += 1;
340
341 return 0;
342 }
343
344 static uint64_t fileid_mapping_nolock_extid(uint64_t max_slots)
345 {
346 char buf[8+4+HOST_NAME_MAX+1] = { 0, };
347 uint64_t slot = 0;
348 uint64_t id;
349 int rc;
350
351 if (max_slots > 1) {
352 slot = getpid() % max_slots;
353 }
354
355 PUSH_LE_U64(buf, 0, slot);
356 PUSH_LE_U32(buf, 8, get_my_vnn());
357
358 rc = gethostname(&buf[12], HOST_NAME_MAX+1);
359 if (rc != 0) {
360 DBG_ERR("gethostname failed\n");
361 return UINT64_MAX;
362 }
363
364 id = fileid_uint64_hash((uint8_t *)buf, ARRAY_SIZE(buf));
365
366 return id;
367 }
368
369 /* device mapping functions using a fsid */
370 static uint64_t fileid_device_mapping_fsid(struct fileid_handle_data *data,
371 const SMB_STRUCT_STAT *sbuf)
372 {
373 struct fileid_mount_entry *m;
374
375 m = fileid_find_mount_entry(data, sbuf->st_ex_dev);
376 if (!m) return sbuf->st_ex_dev;
377
378 if (m->devid == (uint64_t)-1) {
379 if (sizeof(fsid_t) > sizeof(uint64_t)) {
380 m->devid = fileid_uint64_hash((uint8_t *)&m->fsid,
381 sizeof(m->fsid));
382 } else {
383 union {
384 uint64_t ret;
385 fsid_t fsid;
386 } u;
387 ZERO_STRUCT(u);
388 u.fsid = m->fsid;
389 m->devid = u.ret;
390 }
391 }
392
393 return m->devid;
394 }
395
396 static struct file_id fileid_mapping_fsid(struct fileid_handle_data *data,
397 const SMB_STRUCT_STAT *sbuf)
398 {
399 struct file_id id = { .inode = sbuf->st_ex_ino, };
400
401 id.devid = fileid_device_mapping_fsid(data, sbuf);
402
403 return id;
404 }
405
406 static struct file_id fileid_mapping_next_module(struct fileid_handle_data *data,
407 const SMB_STRUCT_STAT *sbuf)
408 {
409 return SMB_VFS_NEXT_FILE_ID_CREATE(data->handle, sbuf);
410 }
411
412 static int get_connectpath_ino(struct vfs_handle_struct *handle,
413 const char *path,
414 SMB_STRUCT_STAT *psbuf)
415 {
416 TALLOC_CTX *frame = talloc_stackframe();
417 struct smb_filename *fname = NULL;
418 const char *fullpath = NULL;
419 int ret;
420
421 if (path[0] == '/') {
422 fullpath = path;
423 } else {
424 fullpath = talloc_asprintf(frame,
425 "%s/%s",
426 handle->conn->connectpath,
427 path);
428 if (fullpath == NULL) {
429 DBG_ERR("talloc_asprintf() failed\n");
430 TALLOC_FREE(frame);
431 return -1;
432 }
433 }
434
435 fname = synthetic_smb_fname(frame,
436 fullpath,
437 NULL,
438 NULL,
439 0,
440 0);
441 if (fname == NULL) {
442 DBG_ERR("synthetic_smb_fname(%s) failed - %s\n",
443 fullpath, strerror(errno));
444 TALLOC_FREE(frame);
445 return -1;
446 }
447
448 ret = SMB_VFS_NEXT_STAT(handle, fname);
449 if (ret != 0) {
450 DBG_ERR("stat failed for %s with %s\n",
451 fullpath, strerror(errno));
452 TALLOC_FREE(frame);
453 return -1;
454 }
455 *psbuf = fname->st;
456
457 TALLOC_FREE(frame);
458
459 return 0;
460 }
461
462 static int fileid_connect(struct vfs_handle_struct *handle,
463 const char *service, const char *user)
464 {
465 struct fileid_handle_data *data;
466 const char *algorithm;
467 const char **fstype_deny_list = NULL;
468 const char **fstype_allow_list = NULL;
469 const char **mntdir_deny_list = NULL;
470 const char **mntdir_allow_list = NULL;
471 ino_t nolockinode;
472 uint64_t max_slots = 0;
473 bool rootdir_nolock = false;
474 const char **nolock_paths = NULL;
475 size_t i;
476 int saved_errno;
477 int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
478
479 if (ret < 0) {
480 return ret;
481 }
482
483 data = talloc_zero(handle, struct fileid_handle_data);
484 if (!data) {
485 saved_errno = errno;
486 SMB_VFS_NEXT_DISCONNECT(handle);
487 DEBUG(0, ("talloc_zero() failed\n"));
488 errno = saved_errno;
489 return -1;
490 }
491 data->handle = handle;
492
493 /*
494 * "fileid:mapping" is only here as fallback for old setups
495 * "fileid:algorithm" is the option new setups should use
496 */
497 algorithm = lp_parm_const_string(SNUM(handle->conn),
498 "fileid", "mapping",
499 "fsname");
500 algorithm = lp_parm_const_string(SNUM(handle->conn),
501 "fileid", "algorithm",
502 algorithm);
503 if (strcmp("fsname", algorithm) == 0) {
504 data->mapping_fn = fileid_mapping_fsname;
505 } else if (strcmp("fsname_nodirs", algorithm) == 0) {
506 data->mapping_fn = fileid_mapping_fsname;
507 data->nolock.force_all_dirs = true;
508 } else if (strcmp("fsid", algorithm) == 0) {
509 data->mapping_fn = fileid_mapping_fsid;
510 } else if (strcmp("hostname", algorithm) == 0) {
511 data->mapping_fn = fileid_mapping_hostname;
512 data->nolock.force_all_inodes = true;
513 } else if (strcmp("fsname_norootdir", algorithm) == 0) {
514 data->mapping_fn = fileid_mapping_fsname;
515 rootdir_nolock = true;
516 } else if (strcmp("fsname_norootdir_ext", algorithm) == 0) {
517 data->mapping_fn = fileid_mapping_fsname;
518 rootdir_nolock = true;
519 max_slots = UINT64_MAX;
520 } else if (strcmp("next_module", algorithm) == 0) {
521 data->mapping_fn = fileid_mapping_next_module;
522 } else {
523 SMB_VFS_NEXT_DISCONNECT(handle);
524 DEBUG(0,("fileid_connect(): unknown algorithm[%s]\n", algorithm));
525 return -1;
526 }
527
528 fstype_deny_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
529 "fstype deny", NULL);
530 if (fstype_deny_list != NULL) {
531 data->fstype_deny_list = str_list_copy(data, fstype_deny_list);
532 if (data->fstype_deny_list == NULL) {
533 saved_errno = errno;
534 DBG_ERR("str_list_copy failed\n");
535 SMB_VFS_NEXT_DISCONNECT(handle);
536 errno = saved_errno;
537 return -1;
538 }
539 }
540
541 fstype_allow_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
542 "fstype allow", NULL);
543 if (fstype_allow_list != NULL) {
544 data->fstype_allow_list = str_list_copy(data, fstype_allow_list);
545 if (data->fstype_allow_list == NULL) {
546 saved_errno = errno;
547 DBG_ERR("str_list_copy failed\n");
548 SMB_VFS_NEXT_DISCONNECT(handle);
549 errno = saved_errno;
550 return -1;
551 }
552 }
553
554 mntdir_deny_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
555 "mntdir deny", NULL);
556 if (mntdir_deny_list != NULL) {
557 data->mntdir_deny_list = str_list_copy(data, mntdir_deny_list);
558 if (data->mntdir_deny_list == NULL) {
559 saved_errno = errno;
560 DBG_ERR("str_list_copy failed\n");
561 SMB_VFS_NEXT_DISCONNECT(handle);
562 errno = saved_errno;
563 return -1;
564 }
565 }
566
567 mntdir_allow_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
568 "mntdir allow", NULL);
569 if (mntdir_allow_list != NULL) {
570 data->mntdir_allow_list = str_list_copy(data, mntdir_allow_list);
571 if (data->mntdir_allow_list == NULL) {
572 saved_errno = errno;
573 DBG_ERR("str_list_copy failed\n");
574 SMB_VFS_NEXT_DISCONNECT(handle);
575 errno = saved_errno;
576 return -1;
577 }
578 }
579
580 data->nolock.force_all_inodes = lp_parm_bool(SNUM(handle->conn),
581 "fileid", "nolock_all_inodes",
582 data->nolock.force_all_inodes);
583 data->nolock.force_all_dirs = lp_parm_bool(SNUM(handle->conn),
584 "fileid", "nolock_all_dirs",
585 data->nolock.force_all_dirs);
586
587 max_slots = lp_parm_ulonglong(SNUM(handle->conn),
588 "fileid", "nolock_max_slots",
589 max_slots);
590 max_slots = MAX(max_slots, 1);
591
592 data->nolock.extid = fileid_mapping_nolock_extid(max_slots);
593
594 nolockinode = lp_parm_ulong(SNUM(handle->conn), "fileid", "nolockinode", 0);
595 if (nolockinode != 0) {
596 SMB_STRUCT_STAT tmpsbuf = { .st_ex_ino = nolockinode, };
597
598 ret = fileid_add_nolock_inode(data, &tmpsbuf);
599 if (ret != 0) {
600 saved_errno = errno;
601 SMB_VFS_NEXT_DISCONNECT(handle);
602 errno = saved_errno;
603 return -1;
604 }
605 }
606
607 if (rootdir_nolock) {
608 SMB_STRUCT_STAT rootdirsbuf;
609
610 ret = get_connectpath_ino(handle, ".", &rootdirsbuf);
611 if (ret != 0) {
612 saved_errno = errno;
613 SMB_VFS_NEXT_DISCONNECT(handle);
614 errno = saved_errno;
615 return -1;
616 }
617
618 ret = fileid_add_nolock_inode(data, &rootdirsbuf);
619 if (ret != 0) {
620 saved_errno = errno;
621 SMB_VFS_NEXT_DISCONNECT(handle);
622 errno = saved_errno;
623 return -1;
624 }
625 }
626
627 nolock_paths = lp_parm_string_list(SNUM(handle->conn), "fileid", "nolock_paths", NULL);
628 for (i = 0; nolock_paths != NULL && nolock_paths[i] != NULL; i++) {
629 SMB_STRUCT_STAT tmpsbuf;
630
631 ret = get_connectpath_ino(handle, nolock_paths[i], &tmpsbuf);
632 if (ret == -1 && errno == ENOENT) {
633 DBG_ERR("ignoring non existing nolock_paths[%zu]='%s'\n",
634 i, nolock_paths[i]);
635 continue;
636 }
637 if (ret != 0) {
638 saved_errno = errno;
639 SMB_VFS_NEXT_DISCONNECT(handle);
640 errno = saved_errno;
641 return -1;
642 }
643
644 ret = fileid_add_nolock_inode(data, &tmpsbuf);
645 if (ret != 0) {
646 saved_errno = errno;
647 SMB_VFS_NEXT_DISCONNECT(handle);
648 errno = saved_errno;
649 return -1;
650 }
651 DBG_DEBUG("Adding nolock_paths[%zu]='%s'\n",
652 i, nolock_paths[i]);
653 }
654
655 SMB_VFS_HANDLE_SET_DATA(handle, data, NULL,
656 struct fileid_handle_data,
657 return -1);
658
659 DBG_DEBUG("connect to service[%s] with algorithm[%s] nolock.inodes %zu\n",
660 service, algorithm, data->nolock.num_inodes);
661
662 return 0;
663 }
664
665 static void fileid_disconnect(struct vfs_handle_struct *handle)
666 {
667 const struct loadparm_substitution *lp_sub =
668 loadparm_s3_global_substitution();
669
670 DEBUG(10,("fileid_disconnect() connect to service[%s].\n",
671 lp_servicename(talloc_tos(), lp_sub, SNUM(handle->conn))));
672
673 SMB_VFS_NEXT_DISCONNECT(handle);
674 }
675
676 static struct file_id fileid_file_id_create(struct vfs_handle_struct *handle,
677 const SMB_STRUCT_STAT *sbuf)
678 {
679 struct fileid_handle_data *data;
680 struct file_id id = { .inode = 0, };
681
682 SMB_VFS_HANDLE_GET_DATA(handle, data,
683 struct fileid_handle_data,
684 return id);
685
686 id = data->mapping_fn(data, sbuf);
687 if (id.extid == 0 && fileid_is_nolock_inode(data, sbuf)) {
688 id.extid = data->nolock.extid;
689 }
690
691 DBG_DEBUG("Returning dev [%jx] inode [%jx] extid [%jx]\n",
692 (uintmax_t)id.devid, (uintmax_t)id.inode, (uintmax_t)id.extid);
693
694 return id;
695 }
696
697 static struct vfs_fn_pointers vfs_fileid_fns = {
698 .connect_fn = fileid_connect,
699 .disconnect_fn = fileid_disconnect,
700 .file_id_create_fn = fileid_file_id_create
701 };
702
703 static_decl_vfs;
704 NTSTATUS vfs_fileid_init(TALLOC_CTX *ctx)
705 {
706 NTSTATUS ret;
707
708 ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fileid",
709 &vfs_fileid_fns);
710 if (!NT_STATUS_IS_OK(ret)) {
711 return ret;
712 }
713
714 vfs_fileid_debug_level = debug_add_class("fileid");
715 if (vfs_fileid_debug_level == -1) {
716 vfs_fileid_debug_level = DBGC_VFS;
717 DEBUG(0, ("vfs_fileid: Couldn't register custom debugging class!\n"));
718 } else {
719 DEBUG(10, ("vfs_fileid: Debug class number of 'fileid': %d\n", vfs_fileid_debug_level));
720 }
721
722 return ret;
723 }
Samba GIT mirror