LCOV - code coverage report
Current view: top level - source3/modules - vfs_fileid.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 7 243 2.9 %
Date: 2021-09-23 10:06:22 Functions: 1 15 6.7 %

          Line data    Source code
       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_handle_data {
      39             :         uint64_t (*device_mapping_fn)(struct fileid_handle_data *data,
      40             :                                       const SMB_STRUCT_STAT *sbuf);
      41             :         uint64_t (*extid_mapping_fn)(struct fileid_handle_data *data,
      42             :                                       const SMB_STRUCT_STAT *sbuf);
      43             :         char **fstype_deny_list;
      44             :         char **fstype_allow_list;
      45             :         char **mntdir_deny_list;
      46             :         char **mntdir_allow_list;
      47             :         unsigned num_mount_entries;
      48             :         struct fileid_mount_entry *mount_entries;
      49             :         ino_t nolockinode;
      50             : };
      51             : 
      52             : /* check if a mount entry is allowed based on fstype and mount directory */
      53           0 : static bool fileid_mount_entry_allowed(struct fileid_handle_data *data,
      54             :                                        struct mntent *m)
      55             : {
      56             :         int i;
      57           0 :         char **fstype_deny = data->fstype_deny_list;
      58           0 :         char **fstype_allow = data->fstype_allow_list;
      59           0 :         char **mntdir_deny = data->mntdir_deny_list;
      60           0 :         char **mntdir_allow = data->mntdir_allow_list;
      61             : 
      62           0 :         if (fstype_deny != NULL) {
      63           0 :                 for (i = 0; fstype_deny[i] != NULL; i++) {
      64           0 :                         if (strcmp(m->mnt_type, fstype_deny[i]) == 0) {
      65           0 :                                 return false;
      66             :                         }
      67             :                 }
      68             :         }
      69           0 :         if (fstype_allow != NULL) {
      70           0 :                 for (i = 0; fstype_allow[i] != NULL; i++) {
      71           0 :                         if (strcmp(m->mnt_type, fstype_allow[i]) == 0) {
      72           0 :                                 break;
      73             :                         }
      74             :                 }
      75           0 :                 if (fstype_allow[i] == NULL) {
      76           0 :                         return false;
      77             :                 }
      78             :         }
      79           0 :         if (mntdir_deny != NULL) {
      80           0 :                 for (i=0; mntdir_deny[i] != NULL; i++) {
      81           0 :                         if (strcmp(m->mnt_dir, mntdir_deny[i]) == 0) {
      82           0 :                                 return false;
      83             :                         }
      84             :                 }
      85             :         }
      86           0 :         if (mntdir_allow != NULL) {
      87           0 :                 for (i=0; mntdir_allow[i] != NULL; i++) {
      88           0 :                         if (strcmp(m->mnt_dir, mntdir_allow[i]) == 0) {
      89           0 :                                 break;
      90             :                         }
      91             :                 }
      92           0 :                 if (mntdir_allow[i] == NULL) {
      93           0 :                         return false;
      94             :                 }
      95             :         }
      96           0 :         return true;
      97             : }
      98             : 
      99             : 
     100             : /* load all the mount entries from the mtab */
     101           0 : static void fileid_load_mount_entries(struct fileid_handle_data *data)
     102             : {
     103             :         FILE *f;
     104             :         struct mntent *m;
     105             : 
     106           0 :         data->num_mount_entries = 0;
     107           0 :         TALLOC_FREE(data->mount_entries);
     108             : 
     109           0 :         f = setmntent("/etc/mtab", "r");
     110           0 :         if (!f) return;
     111             : 
     112           0 :         while ((m = getmntent(f))) {
     113             :                 struct stat st;
     114             :                 struct statfs sfs;
     115             :                 struct fileid_mount_entry *cur;
     116             :                 bool allowed;
     117             : 
     118           0 :                 allowed = fileid_mount_entry_allowed(data, m);
     119           0 :                 if (!allowed) {
     120           0 :                         DBG_DEBUG("skipping mount entry %s\n", m->mnt_dir);
     121           0 :                         continue;
     122             :                 }
     123           0 :                 if (stat(m->mnt_dir, &st) != 0) continue;
     124           0 :                 if (statfs(m->mnt_dir, &sfs) != 0) continue;
     125             : 
     126           0 :                 if (strncmp(m->mnt_fsname, "/dev/", 5) == 0) {
     127           0 :                         m->mnt_fsname += 5;
     128             :                 }
     129             : 
     130           0 :                 data->mount_entries = talloc_realloc(data,
     131             :                                                            data->mount_entries,
     132             :                                                            struct fileid_mount_entry,
     133             :                                                            data->num_mount_entries+1);
     134           0 :                 if (data->mount_entries == NULL) {
     135           0 :                         goto nomem;
     136             :                 }
     137             : 
     138           0 :                 cur = &data->mount_entries[data->num_mount_entries];
     139           0 :                 cur->device  = st.st_dev;
     140           0 :                 cur->mnt_fsname = talloc_strdup(data->mount_entries,
     141           0 :                                                 m->mnt_fsname);
     142           0 :                 if (!cur->mnt_fsname) goto nomem;
     143           0 :                 cur->fsid    = sfs.f_fsid;
     144           0 :                 cur->devid   = (uint64_t)-1;
     145             : 
     146           0 :                 data->num_mount_entries++;
     147             :         }
     148           0 :         endmntent(f);
     149           0 :         return;
     150             :         
     151           0 : nomem:
     152           0 :         if (f) endmntent(f);
     153             : 
     154           0 :         data->num_mount_entries = 0;
     155           0 :         TALLOC_FREE(data->mount_entries);
     156             : 
     157           0 :         return;
     158             : }
     159             : 
     160             : /* find a mount entry given a dev_t */
     161           0 : static struct fileid_mount_entry *fileid_find_mount_entry(struct fileid_handle_data *data,
     162             :                                                           SMB_DEV_T dev)
     163             : {
     164             :         unsigned i;
     165             : 
     166           0 :         if (data->num_mount_entries == 0) {
     167           0 :                 fileid_load_mount_entries(data);
     168             :         }
     169           0 :         for (i=0;i<data->num_mount_entries;i++) {
     170           0 :                 if (data->mount_entries[i].device == dev) {
     171           0 :                         return &data->mount_entries[i];
     172             :                 }
     173             :         }
     174             :         /* 2nd pass after reloading */
     175           0 :         fileid_load_mount_entries(data);
     176           0 :         for (i=0;i<data->num_mount_entries;i++) {
     177           0 :                 if (data->mount_entries[i].device == dev) {
     178           0 :                         return &data->mount_entries[i];
     179             :                 }
     180             :         }       
     181           0 :         return NULL;
     182             : }
     183             : 
     184             : 
     185             : /* a 64 bit hash, based on the one in tdb */
     186           0 : static uint64_t fileid_uint64_hash(const uint8_t *s, size_t len)
     187             : {
     188             :         uint64_t value; /* Used to compute the hash value.  */
     189             :         uint32_t i;     /* Used to cycle through random values. */
     190             : 
     191             :         /* Set the initial value from the key size. */
     192           0 :         for (value = 0x238F13AFLL * len, i=0; i < len; i++)
     193           0 :                 value = (value + (((uint64_t)s[i]) << (i*5 % 24)));
     194             : 
     195           0 :         return (1103515243LL * value + 12345LL);
     196             : }
     197             : 
     198             : /* a device mapping using a fsname */
     199           0 : static uint64_t fileid_device_mapping_fsname(struct fileid_handle_data *data,
     200             :                                              const SMB_STRUCT_STAT *sbuf)
     201             : {
     202             :         struct fileid_mount_entry *m;
     203             : 
     204           0 :         m = fileid_find_mount_entry(data, sbuf->st_ex_dev);
     205           0 :         if (!m) return sbuf->st_ex_dev;
     206             : 
     207           0 :         if (m->devid == (uint64_t)-1) {
     208           0 :                 m->devid = fileid_uint64_hash((const uint8_t *)m->mnt_fsname,
     209             :                                               strlen(m->mnt_fsname));
     210             :         }
     211             : 
     212           0 :         return m->devid;
     213             : }
     214             : 
     215             : /* a device mapping using a hostname */
     216           0 : static uint64_t fileid_device_mapping_hostname(struct fileid_handle_data *data,
     217             :                                                const SMB_STRUCT_STAT *sbuf)
     218             : {
     219             :         char hostname[HOST_NAME_MAX+1];
     220           0 :         char *devname = NULL;
     221             :         uint64_t id;
     222             :         size_t devname_len;
     223             :         int rc;
     224             : 
     225           0 :         rc = gethostname(hostname, HOST_NAME_MAX+1);
     226           0 :         if (rc != 0) {
     227           0 :                 DBG_ERR("gethostname failed\n");
     228           0 :                 return UINT64_MAX;
     229             :         }
     230             : 
     231           0 :         devname = talloc_asprintf(talloc_tos(), "%s%ju",
     232           0 :                                   hostname, (uintmax_t)sbuf->st_ex_dev);
     233           0 :         if (devname == NULL) {
     234           0 :                 DBG_ERR("talloc_asprintf failed\n");
     235           0 :                 return UINT64_MAX;
     236             :         }
     237           0 :         devname_len = talloc_array_length(devname) - 1;
     238             : 
     239           0 :         id = fileid_uint64_hash((uint8_t *)devname, devname_len);
     240             : 
     241           0 :         TALLOC_FREE(devname);
     242             : 
     243           0 :         return id;
     244             : }
     245             : 
     246             : /* a device mapping using a fsname for files and hostname for dirs */
     247           0 : static uint64_t fileid_device_mapping_fsname_nodirs(
     248             :         struct fileid_handle_data *data,
     249             :         const SMB_STRUCT_STAT *sbuf)
     250             : {
     251           0 :         if (S_ISDIR(sbuf->st_ex_mode)) {
     252           0 :                 return fileid_device_mapping_hostname(data, sbuf);
     253             :         }
     254             : 
     255           0 :         return fileid_device_mapping_fsname(data, sbuf);
     256             : }
     257             : 
     258             : /* device mapping functions using a fsid */
     259           0 : static uint64_t fileid_device_mapping_fsid(struct fileid_handle_data *data,
     260             :                                            const SMB_STRUCT_STAT *sbuf)
     261             : {
     262             :         struct fileid_mount_entry *m;
     263             : 
     264           0 :         m = fileid_find_mount_entry(data, sbuf->st_ex_dev);
     265           0 :         if (!m) return sbuf->st_ex_dev;
     266             : 
     267           0 :         if (m->devid == (uint64_t)-1) {
     268             :                 if (sizeof(fsid_t) > sizeof(uint64_t)) {
     269             :                         m->devid = fileid_uint64_hash((uint8_t *)&m->fsid,
     270             :                                                       sizeof(m->fsid));
     271             :                 } else {
     272             :                         union {
     273             :                                 uint64_t ret;
     274             :                                 fsid_t fsid;
     275             :                         } u;
     276           0 :                         ZERO_STRUCT(u);
     277           0 :                         u.fsid = m->fsid;
     278           0 :                         m->devid = u.ret;
     279             :                 }
     280             :         }
     281             : 
     282           0 :         return m->devid;
     283             : }
     284             : 
     285           0 : static uint64_t fileid_extid_mapping_zero(struct fileid_handle_data *data,
     286             :                                           const SMB_STRUCT_STAT *sbuf)
     287             : {
     288           0 :         return 0;
     289             : }
     290             : 
     291           0 : static uint64_t fileid_extid_mapping_pid(struct fileid_handle_data *data,
     292             :                                          const SMB_STRUCT_STAT *sbuf)
     293             : {
     294           0 :         return getpid();
     295             : }
     296             : 
     297           0 : static int get_connectpath_ino(struct vfs_handle_struct *handle,
     298             :                                ino_t *ino)
     299             : {
     300           0 :         struct smb_filename *fname = NULL;
     301             :         int ret;
     302             : 
     303           0 :         fname = synthetic_smb_fname(talloc_tos(),
     304           0 :                                     handle->conn->connectpath,
     305             :                                     NULL,
     306             :                                     NULL,
     307             :                                     0,
     308             :                                     0);
     309           0 :         if (fname == NULL) {
     310           0 :                 DBG_ERR("synthetic_smb_fname failed\n");
     311           0 :                 return -1;
     312             :         }
     313             : 
     314           0 :         ret = SMB_VFS_NEXT_STAT(handle, fname);
     315           0 :         if (ret != 0) {
     316           0 :                 DBG_ERR("stat failed for %s with %s\n",
     317             :                         handle->conn->connectpath, strerror(errno));
     318           0 :                 TALLOC_FREE(fname);
     319           0 :                 return -1;
     320             :         }
     321           0 :         *ino = fname->st.st_ex_ino;
     322           0 :         TALLOC_FREE(fname);
     323             : 
     324           0 :         return 0;
     325             : }
     326             : 
     327           0 : static int fileid_connect(struct vfs_handle_struct *handle,
     328             :                           const char *service, const char *user)
     329             : {
     330             :         struct fileid_handle_data *data;
     331             :         const char *algorithm;
     332           0 :         const char **fstype_deny_list = NULL;
     333           0 :         const char **fstype_allow_list = NULL;
     334           0 :         const char **mntdir_deny_list = NULL;
     335           0 :         const char **mntdir_allow_list = NULL;
     336             :         int saved_errno;
     337           0 :         int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
     338             : 
     339           0 :         if (ret < 0) {
     340           0 :                 return ret;
     341             :         }
     342             : 
     343           0 :         data = talloc_zero(handle->conn, struct fileid_handle_data);
     344           0 :         if (!data) {
     345           0 :                 saved_errno = errno;
     346           0 :                 SMB_VFS_NEXT_DISCONNECT(handle);
     347           0 :                 DEBUG(0, ("talloc_zero() failed\n"));
     348           0 :                 errno = saved_errno;
     349           0 :                 return -1;
     350             :         }
     351             : 
     352           0 :         data->nolockinode = 0;
     353             : 
     354             :         /*
     355             :          * "fileid:mapping" is only here as fallback for old setups
     356             :          * "fileid:algorithm" is the option new setups should use
     357             :          */
     358           0 :         algorithm = lp_parm_const_string(SNUM(handle->conn),
     359             :                                          "fileid", "mapping",
     360             :                                          "fsname");
     361           0 :         algorithm = lp_parm_const_string(SNUM(handle->conn),
     362             :                                          "fileid", "algorithm",
     363             :                                          algorithm);
     364           0 :         if (strcmp("fsname", algorithm) == 0) {
     365           0 :                 data->device_mapping_fn      = fileid_device_mapping_fsname;
     366           0 :                 data->extid_mapping_fn = fileid_extid_mapping_zero;
     367           0 :         } else if (strcmp("fsname_nodirs", algorithm) == 0) {
     368           0 :                 data->device_mapping_fn = fileid_device_mapping_fsname_nodirs;
     369           0 :                 data->extid_mapping_fn = fileid_extid_mapping_zero;
     370           0 :         } else if (strcmp("fsid", algorithm) == 0) {
     371           0 :                 data->device_mapping_fn      = fileid_device_mapping_fsid;
     372           0 :                 data->extid_mapping_fn = fileid_extid_mapping_zero;
     373           0 :         } else if (strcmp("hostname", algorithm) == 0) {
     374           0 :                 data->device_mapping_fn = fileid_device_mapping_hostname;
     375           0 :                 data->extid_mapping_fn = fileid_extid_mapping_zero;
     376           0 :         } else if (strcmp("fsname_norootdir", algorithm) == 0) {
     377           0 :                 data->device_mapping_fn      = fileid_device_mapping_fsname;
     378           0 :                 data->extid_mapping_fn = fileid_extid_mapping_zero;
     379             : 
     380           0 :                 ret = get_connectpath_ino(handle, &data->nolockinode);
     381           0 :                 if (ret != 0) {
     382           0 :                         saved_errno = errno;
     383           0 :                         SMB_VFS_NEXT_DISCONNECT(handle);
     384           0 :                         errno = saved_errno;
     385           0 :                         return -1;
     386             :                 }
     387           0 :         } else if (strcmp("fsname_norootdir_ext", algorithm) == 0) {
     388           0 :                 data->device_mapping_fn      = fileid_device_mapping_fsname;
     389           0 :                 data->extid_mapping_fn = fileid_extid_mapping_pid;
     390             : 
     391           0 :                 ret = get_connectpath_ino(handle, &data->nolockinode);
     392           0 :                 if (ret != 0) {
     393           0 :                         saved_errno = errno;
     394           0 :                         SMB_VFS_NEXT_DISCONNECT(handle);
     395           0 :                         errno = saved_errno;
     396           0 :                         return -1;
     397             :                 }
     398             :         } else {
     399           0 :                 SMB_VFS_NEXT_DISCONNECT(handle);
     400           0 :                 DEBUG(0,("fileid_connect(): unknown algorithm[%s]\n", algorithm));
     401           0 :                 return -1;
     402             :         }
     403             : 
     404           0 :         fstype_deny_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
     405             :                                                "fstype deny", NULL);
     406           0 :         if (fstype_deny_list != NULL) {
     407           0 :                 data->fstype_deny_list = str_list_copy(data, fstype_deny_list);
     408           0 :                 if (data->fstype_deny_list == NULL) {
     409           0 :                         saved_errno = errno;
     410           0 :                         DBG_ERR("str_list_copy failed\n");
     411           0 :                         SMB_VFS_NEXT_DISCONNECT(handle);
     412           0 :                         errno = saved_errno;
     413           0 :                         return -1;
     414             :                 }
     415             :         }
     416             : 
     417           0 :         fstype_allow_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
     418             :                                                 "fstype allow", NULL);
     419           0 :         if (fstype_allow_list != NULL) {
     420           0 :                 data->fstype_allow_list = str_list_copy(data, fstype_allow_list);
     421           0 :                 if (data->fstype_allow_list == NULL) {
     422           0 :                         saved_errno = errno;
     423           0 :                         DBG_ERR("str_list_copy failed\n");
     424           0 :                         SMB_VFS_NEXT_DISCONNECT(handle);
     425           0 :                         errno = saved_errno;
     426           0 :                         return -1;
     427             :                 }
     428             :         }
     429             : 
     430           0 :         mntdir_deny_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
     431             :                                                "mntdir deny", NULL);
     432           0 :         if (mntdir_deny_list != NULL) {
     433           0 :                 data->mntdir_deny_list = str_list_copy(data, mntdir_deny_list);
     434           0 :                 if (data->mntdir_deny_list == NULL) {
     435           0 :                         saved_errno = errno;
     436           0 :                         DBG_ERR("str_list_copy failed\n");
     437           0 :                         SMB_VFS_NEXT_DISCONNECT(handle);
     438           0 :                         errno = saved_errno;
     439           0 :                         return -1;
     440             :                 }
     441             :         }
     442             : 
     443           0 :         mntdir_allow_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
     444             :                                                 "mntdir allow", NULL);
     445           0 :         if (mntdir_allow_list != NULL) {
     446           0 :                 data->mntdir_allow_list = str_list_copy(data, mntdir_allow_list);
     447           0 :                 if (data->mntdir_allow_list == NULL) {
     448           0 :                         saved_errno = errno;
     449           0 :                         DBG_ERR("str_list_copy failed\n");
     450           0 :                         SMB_VFS_NEXT_DISCONNECT(handle);
     451           0 :                         errno = saved_errno;
     452           0 :                         return -1;
     453             :                 }
     454             :         }
     455             : 
     456           0 :         data->nolockinode = lp_parm_ulong(SNUM(handle->conn), "fileid",
     457             :                                           "nolockinode", data->nolockinode);
     458             : 
     459           0 :         SMB_VFS_HANDLE_SET_DATA(handle, data, NULL,
     460             :                                 struct fileid_handle_data,
     461             :                                 return -1);
     462             : 
     463           0 :         DBG_DEBUG("connect to service[%s] with algorithm[%s] nolockinode %lli\n",
     464             :                   service, algorithm, (long long) data->nolockinode);
     465             : 
     466           0 :         return 0;
     467             : }
     468             : 
     469           0 : static void fileid_disconnect(struct vfs_handle_struct *handle)
     470             : {
     471           0 :         const struct loadparm_substitution *lp_sub =
     472             :                 loadparm_s3_global_substitution();
     473             : 
     474           0 :         DEBUG(10,("fileid_disconnect() connect to service[%s].\n",
     475             :                   lp_servicename(talloc_tos(), lp_sub, SNUM(handle->conn))));
     476             : 
     477           0 :         SMB_VFS_NEXT_DISCONNECT(handle);
     478           0 : }
     479             : 
     480           0 : static struct file_id fileid_file_id_create(struct vfs_handle_struct *handle,
     481             :                                             const SMB_STRUCT_STAT *sbuf)
     482             : {
     483             :         struct fileid_handle_data *data;
     484             :         struct file_id id;
     485             :         uint64_t devid;
     486             : 
     487           0 :         ZERO_STRUCT(id);
     488             : 
     489           0 :         SMB_VFS_HANDLE_GET_DATA(handle, data,
     490             :                                 struct fileid_handle_data,
     491             :                                 return id);
     492             : 
     493           0 :         if ((data->nolockinode != 0) &&
     494           0 :             (sbuf->st_ex_ino == data->nolockinode)) {
     495           0 :                 devid = fileid_device_mapping_hostname(data, sbuf);
     496           0 :                 id.extid = data->extid_mapping_fn(data, sbuf);
     497             :         } else {
     498           0 :                 devid = data->device_mapping_fn(data, sbuf);
     499             :         }
     500             : 
     501           0 :         id.inode        = sbuf->st_ex_ino;
     502           0 :         id.devid        = devid;
     503             : 
     504           0 :         DBG_DEBUG("Returning dev [%jx] inode [%jx] extid [%jx]\n",
     505             :                   (uintmax_t)id.devid, (uintmax_t)id.inode, (uintmax_t)id.extid);
     506             : 
     507           0 :         return id;
     508             : }
     509             : 
     510             : static struct vfs_fn_pointers vfs_fileid_fns = {
     511             :         .connect_fn = fileid_connect,
     512             :         .disconnect_fn = fileid_disconnect,
     513             :         .file_id_create_fn = fileid_file_id_create
     514             : };
     515             : 
     516             : static_decl_vfs;
     517          20 : NTSTATUS vfs_fileid_init(TALLOC_CTX *ctx)
     518             : {
     519             :         NTSTATUS ret;
     520             : 
     521          20 :         ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fileid",
     522             :                                &vfs_fileid_fns);
     523          20 :         if (!NT_STATUS_IS_OK(ret)) {
     524           0 :                 return ret;
     525             :         }
     526             : 
     527          20 :         vfs_fileid_debug_level = debug_add_class("fileid");
     528          20 :         if (vfs_fileid_debug_level == -1) {
     529           0 :                 vfs_fileid_debug_level = DBGC_VFS;
     530           0 :                 DEBUG(0, ("vfs_fileid: Couldn't register custom debugging class!\n"));
     531             :         } else {
     532          20 :                 DEBUG(10, ("vfs_fileid: Debug class number of 'fileid': %d\n", vfs_fileid_debug_level));
     533             :         }
     534             : 
     535          20 :         return ret;
     536             : }

Generated by: LCOV version 1.13