cp-hash.c

Absolute File Name:

/home/opencoverage/opencoverage/guest-scripts/coreutils/src/src/cp-hash.c

Line

Source

Count

/* cp-hash.c -- file copying (hash search routines)

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <https://www.gnu.org/licenses/>.

Written by Torbjorn Granlund, Sweden (tege@sics.se).

Rewritten to use lib/hash.c by Jim Meyering. */

#include <config.h>

#include <sys/types.h>

#include "system.h"

#include "hash.h"

#include "cp-hash.h"

/* Use ST_DEV and ST_INO as the key, FILENAME as the value.

These are used e.g., in copy.c to associate the destination name with

the source device/inode pair so that if we encounter a matching dev/ino

pair in the source tree we can arrange to create a hard link between

the corresponding names in the destination tree. */

struct Src_to_dest

{

ino_t st_ino;

dev_t st_dev;

/* Destination file name (of non-directory or pre-existing directory)

corresponding to the dev/ino of a copied file, or the destination file

name corresponding to a dev/ino pair for a newly-created directory. */

char *name;

};

/* This table maps source dev/ino to destination file name.

We use it to preserve hard links when copying. */

static Hash_table *src_to_dest;

/* Initial size of the above hash table. */

#define INITIAL_TABLE_SIZE 103

static size_t

src_to_dest_hash (void const *x, size_t table_size)

{

struct Src_to_dest const *p = x;

/* Ignoring the device number here should be fine. */

/* The cast to uintmax_t prevents negative remainders

if st_ino is negative. */

return (uintmax_t) p->st_ino % table_size;

executed 60272 times by 2 tests: return (uintmax_t) p->st_ino % table_size;

Executed by:

60272

}

/* Compare two Src_to_dest entries.

Return true if their keys are judged 'equal'. */

static bool

src_to_dest_compare (void const *x, void const *y)

{

struct Src_to_dest const *a = x;

struct Src_to_dest const *b = y;

return SAME_INODE (*a, *b) ? true : false;

executed 11704 times by 2 tests: return ((*a).st_ino == (*b).st_ino && (*a).st_dev == (*b).st_dev) ? 1 : 0 ;

Executed by:

11704

}

static void

src_to_dest_free (void *x)

{

struct Src_to_dest *a = x;

free (a->name);

free (x);

}

executed 27 times by 2 tests: end of block

Executed by:

/* Remove the entry matching INO/DEV from the table

that maps source ino/dev to destination file name. */

extern void

forget_created (ino_t ino, dev_t dev)

{

struct Src_to_dest probe;

struct Src_to_dest *ent;

probe.st_ino = ino;

probe.st_dev = dev;

probe.name = NULL;

ent = hash_delete (src_to_dest, &probe);

if (ent)

ent	Description
TRUE	evaluated 4 times by 1 test Evaluated by: mv
FALSE	evaluated 9 times by 2 tests Evaluated by: cp mv

4-9

src_to_dest_free (ent);

executed 4 times by 1 test: src_to_dest_free (ent);

Executed by:

}

executed 13 times by 2 tests: end of block

Executed by:

/* If INO/DEV correspond to an already-copied source file, return the

name of the corresponding destination file. Otherwise, return NULL. */

extern char *

100

src_to_dest_lookup (ino_t ino, dev_t dev)

101

{

102

struct Src_to_dest ent;

103

struct Src_to_dest const *e;

104

ent.st_ino = ino;

105

ent.st_dev = dev;

106

e = hash_lookup (src_to_dest, &ent);

107

return e ? e->name : NULL;

executed 34481 times by 2 tests: return e ? e->name : ((void *)0) ;

Executed by:

34481

108

}

109

110

/* Add file NAME, copied from inode number INO and device number DEV,

111

to the list of files we have copied.

112

Return NULL if inserted, otherwise non-NULL. */

113

114

extern char *

115

remember_copied (const char *name, ino_t ino, dev_t dev)

116

{

117

struct Src_to_dest *ent;

118

struct Src_to_dest *ent_from_table;

119

120

ent = xmalloc (sizeof *ent);

121

ent->name = xstrdup (name);

ent->st_ino = ino;

ent->st_dev = dev;

ent_from_table = hash_insert (src_to_dest, ent);

126

if (ent_from_table == NULL)

ent_from_table == ((void *)0)	Description
TRUE	never evaluated
FALSE	evaluated 7959 times by 2 tests Evaluated by: cp mv

0-7959

127

{

128

/* Insertion failed due to lack of memory. */

129

xalloc_die ();

130

}

never executed: end of block

131

132

/* Determine whether there was already an entry in the table

133

with a matching key. If so, free ENT (it wasn't inserted) and

134

return the 'name' from the table entry. */

135

if (ent_from_table != ent)

ent_from_table != ent	Description
TRUE	evaluated 23 times by 2 tests Evaluated by: cp mv
FALSE	evaluated 7936 times by 2 tests Evaluated by: cp mv

23-7936

136

{

137

src_to_dest_free (ent);

138

return (char *) ent_from_table->name;

executed 23 times by 2 tests: return (char *) ent_from_table->name;

Executed by:

139

}

140

141

/* New key; insertion succeeded. */

142

return NULL;

executed 7936 times by 2 tests: return ((void *)0) ;

Executed by:

7936

143

}

144

145

/* Initialize the hash table. */

extern void

hash_init (void)

{

src_to_dest = hash_initialize (INITIAL_TABLE_SIZE, NULL,

src_to_dest_hash,

src_to_dest_compare,

src_to_dest_free);

if (src_to_dest == NULL)

src_to_dest == ((void *)0)	Description
TRUE	never evaluated
FALSE	evaluated 1336 times by 3 tests Evaluated by: cp ginstall mv

0-1336

154

xalloc_die ();

never executed: xalloc_die ();

155

}

executed 1336 times by 3 tests: end of block

Executed by:

cp
ginstall
mv

1336

156

157

/* Reset the hash structure in the global variable 'htab' to

158

contain no entries. */

extern void

forget_all (void)

{

hash_free (src_to_dest);

164

}

never executed: end of block

Generated by Squish Coco 4.1.2