/* The function is NOT SCHEDULE-SAFE! */
int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
struct treepath *path, struct reiserfs_dir_entry *de)
{
int retval;
retval = search_item(sb, key, path);
switch (retval) {
case ITEM_NOT_FOUND:
if (!PATH_LAST_POSITION(path)) {
reiserfs_error(sb, "vs-7000", "search_by_key "
"returned item position == 0");
pathrelse(path);
return IO_ERROR;
}
PATH_LAST_POSITION(path)--;
case ITEM_FOUND:
break;
case IO_ERROR:
return retval;
default:
pathrelse(path);
reiserfs_error(sb, "vs-7002", "no path to here");
return IO_ERROR;
}
set_de_item_location(de, path);
#ifdef CONFIG_REISERFS_CHECK
if (!is_direntry_le_ih(de->de_ih) ||
COMP_SHORT_KEYS(&de->de_ih->ih_key, key)) {
print_block(de->de_bh, 0, -1, -1);
reiserfs_panic(sb, "vs-7005", "found item %h is not directory "
"item or does not belong to the same directory "
"as key %K", de->de_ih, key);
}
#endif /* CONFIG_REISERFS_CHECK */
/*
* binary search in directory item by third component of the
* key. sets de->de_entry_num of de
*/
retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
path->pos_in_item = de->de_entry_num;
if (retval != NAME_NOT_FOUND) {
/*
* ugly, but rename needs de_bh, de_deh, de_name,
* de_namelen, de_objectid set
*/
set_de_name_and_namelen(de);
set_de_object_key(de);
}
return retval;
}
/*
* We assign a key to each directory item, and place multiple entries in
* a single directory item. A directory item has a key equal to the key
* of the first directory entry in it.
*
* This function first calls search_by_key, then, if item whose first
* entry matches is not found it looks for the entry inside directory
* item found by search_by_key. Fills the path to the entry, and to the
* entry position in the item
*/
int
search_by_entry_key(struct reiserfs_sb_info *sbi,
const struct cpu_key *key, struct path *path,
struct reiserfs_dir_entry *de)
{
int retval;
reiserfs_log(LOG_DEBUG, "searching in (objectid=%d,dirid=%d)\n",
key->on_disk_key.k_objectid, key->on_disk_key.k_dir_id);
retval = search_item(sbi, key, path);
switch (retval) {
case ITEM_NOT_FOUND:
if (!PATH_LAST_POSITION(path)) {
reiserfs_log(LOG_DEBUG,
"search_by_key returned item position == 0");
pathrelse(path);
return (IO_ERROR);
}
PATH_LAST_POSITION(path)--;
reiserfs_log(LOG_DEBUG, "search_by_key did not found it\n");
break;
case ITEM_FOUND:
reiserfs_log(LOG_DEBUG, "search_by_key found it\n");
break;
case IO_ERROR:
return (retval);
default:
pathrelse(path);
reiserfs_log(LOG_DEBUG, "no path to here");
return (IO_ERROR);
}
reiserfs_log(LOG_DEBUG, "set item location\n");
set_de_item_location(de, path);
/*
* Binary search in directory item by third component of the
* key. Sets de->de_entry_num of de
*/
reiserfs_log(LOG_DEBUG, "bin_search_in_dir_item\n");
retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
path->pos_in_item = de->de_entry_num;
if (retval != NAME_NOT_FOUND) {
/*
* Ugly, but rename needs de_bp, de_deh, de_name, de_namelen,
* de_objectid set
*/
set_de_name_and_namelen(de);
set_de_object_key(de);
reiserfs_log(LOG_DEBUG, "set (objectid=%d,dirid=%d)\n",
de->de_objectid, de->de_dir_id);
}
return (retval);
}
void enable_find(struct NBT_Window* window) {
move(LINES - 1, 0);
clrtoeol();
printw("Search: ");
refresh();
int ch = 0;
char searchbuf[BUFSIZ];
bzero(searchbuf, sizeof(searchbuf));
const char* s = searchbuf; /* Begin pointer */
char* c = searchbuf; /* Current location */
const char* end = s + sizeof(searchbuf) - 1; /* Max location */
int found = -1;
while((ch = getch()) != 27) {
if (ch == KEY_BACKSPACE || isalnum(ch)) {
if (ch == KEY_BACKSPACE) {
*c = '\0';
if (c != s)
c--;
} else {
if (c < end)
*c++ = ch;
}
move(LINES - 1, 0);
clrtoeol();
printw("Search: %s", searchbuf);
found = search_item(searchbuf, 0, window);
if (found >= 0)
set_current_item(window->menu, window->items[found]);
} else if (KEY_F(3)) {
found = search_item(searchbuf, found + 1, window);
if (found >= 0)
set_current_item(window->menu, window->items[found]);
else {
move(LINES - 1, 0);
clrtoeol();
printw("Search: %s [No more results]", searchbuf);
}
}
refresh();
}
};
int main()
{
// map from author to title; there can be multiple titles per author
multimap<string, string> authors;
// add data to authors
authors.insert(pair<string, string>("Alain de Botton", "book1"));
authors.insert(pair<string, string>("Alain de Botton", "book2"));
authors.insert(pair<string, string>("Alain de Botton", "book3"));
authors.insert(pair<string, string>("Alain de Botton", "book4"));
// author we'll look for
string search_item("Alain de Botton");
// how many entries are there for this author
typedef multimap<string, string>::size_type sz_type;
sz_type entries = authors.count(search_item);
// get iterator to the first entry for this author
multimap<string,string>::iterator iter =
authors.find(search_item);
// loop through the number of entries there are for this author
for (sz_type cnt = 0; cnt != entries; ++cnt, ++iter)
cout << iter->second << endl; // print each title
// definitions of authors and search_item as above
// beg and end denote range of elements for this author
typedef multimap<string, string>::iterator authors_it;
authors_it beg = authors.lower_bound(search_item),
end = authors.upper_bound(search_item);
// loop through the number of entries there are for this author
while (beg != end) {
cout << beg->second << endl; // print each title
++beg;
}
// definitions of authors and search_item as above
// pos holds iterators that denote range of elements for this key
pair<authors_it, authors_it>
pos = authors.equal_range(search_item);
// loop through the number of entries there are for this author
while (pos.first != pos.second) {
cout << pos.first->second << endl; // print each title
++pos.first;
}
return 0;
}
void map_uplow_bound()
{
std::multimap<std::string, int> author;
author.insert(std::make_pair("Jack", 1));
author.insert(std::make_pair("Jack", 2));
author.insert(std::make_pair("Andy", 1));
author.insert(std::make_pair("Frank", 3));
author.insert(std::make_pair("Chris", 1));
author.insert(std::make_pair("Jack", 5));
author.insert(std::make_pair("Jet", 5));
author.insert(std::make_pair("Brian", 4));
mm_iter iter = author.begin();
for (; iter != author.end(); ++iter)
{
std::cout << iter->first << " " << iter->second << std::endl;
}
std::cout << "==============================" << std::endl;
std::string search_item("Jack");
mm_iter search_begin = author.lower_bound(search_item);
mm_iter search_end = author.upper_bound(search_item);
while (search_begin != search_end)
{
std::cout << search_begin->first << " " << search_begin->second << std::endl;
++ search_begin;
}
std::cout << "==============================" << std::endl;
int count = 0;
std::pair<mm_iter, mm_iter> pos = author.equal_range(search_item);
while (pos.first != pos.second)
{
std::cout << pos.first->first << " " << pos.first->second << std::endl;
++ pos.first;
++ count;
}
std::cout << "*** Count:" << count << std::endl;
}
/* The function is NOT SCHEDULE-SAFE! */
int
search_for_position_by_key(struct reiserfs_sb_info *p_s_sbi,
const struct cpu_key *p_cpu_key, /* Key to search (cpu variable) */
struct path *p_s_search_path) /* Filled up by this function. */
{
int retval, n_blk_size;
off_t item_offset, offset;
struct item_head *p_le_ih; /* Pointer to on-disk structure */
struct reiserfs_dir_entry de;
/* If searching for directory entry. */
if (is_direntry_cpu_key(p_cpu_key))
return (search_by_entry_key(p_s_sbi, p_cpu_key,
p_s_search_path, &de));
/* If not searching for directory entry. */
/* If item is found. */
retval = search_item(p_s_sbi, p_cpu_key, p_s_search_path);
if (retval == IO_ERROR)
return (retval);
if (retval == ITEM_FOUND) {
if (ih_item_len(B_N_PITEM_HEAD(
PATH_PLAST_BUFFER(p_s_search_path),
PATH_LAST_POSITION(p_s_search_path))) == 0) {
reiserfs_log(LOG_WARNING, "item length equals zero\n");
}
pos_in_item(p_s_search_path) = 0;
return (POSITION_FOUND);
}
if (PATH_LAST_POSITION(p_s_search_path) == 0) {
reiserfs_log(LOG_WARNING, "position equals zero\n");
}
/* Item is not found. Set path to the previous item. */
p_le_ih = B_N_PITEM_HEAD(PATH_PLAST_BUFFER(p_s_search_path),
--PATH_LAST_POSITION(p_s_search_path));
n_blk_size = p_s_sbi->s_blocksize;
if (comp_short_keys(&(p_le_ih->ih_key), p_cpu_key)) {
return (FILE_NOT_FOUND);
}
item_offset = le_ih_k_offset(p_le_ih);
offset = cpu_key_k_offset(p_cpu_key);
/* Needed byte is contained in the item pointed to by the path.*/
if (item_offset <= offset &&
item_offset + op_bytes_number(p_le_ih, n_blk_size) > offset) {
pos_in_item(p_s_search_path) = offset - item_offset;
if (is_indirect_le_ih(p_le_ih)) {
pos_in_item(p_s_search_path) /= n_blk_size;
}
return (POSITION_FOUND);
}
/* Needed byte is not contained in the item pointed to by the
* path. Set pos_in_item out of the item. */
if (is_indirect_le_ih(p_le_ih))
pos_in_item(p_s_search_path) =
ih_item_len(p_le_ih) / UNFM_P_SIZE;
else
pos_in_item(p_s_search_path) =
ih_item_len(p_le_ih);
return (POSITION_NOT_FOUND);
}
int main()
{
/*
**********************************************************************
* text read:
Alice Emma has long flowing red hair. Her Daddy says
when the wind blows through her hair, it looks almost alive,
like a fiery bird in flight. A beautiful fiery bird, he tells her,
magical but untamed. "Daddy, shush, there is no such thing,"
she tells him, at the same time wanting him to tell her more.
Shyly, she asks, "I mean, Daddy, is there?"
**********************************************************************
* output of program:
* count(): fiery occurs 2 times
**********************************************************************
*/
ifstream infile( "alice_emma" );
assert ( infile != 0 );
list<string,allocator> textlines;
typedef list<string,allocator>::difference_type diff_type;
istream_iterator< string, diff_type > instream( infile ), eos;
copy( instream, eos, back_inserter( textlines ));
string search_item( "fiery" );
/************************************************************
* note: this is the Standard C++ interface for using count()
* however, the current RogueWave implementation
* supports the earlier version in which distance_type
* had not been developed, and so count() returned its
* value via a final argument to itself.
*
* this is how the invocation should occur:
*
************************************************************
*
* typedef iterator_traits<InputIterator>::
* distance_type dis_type;
*
* dis_type elem_count;
* elem_count = count( textlines.begin(), textlines.end(), search_item );
***********************************************************************
*/
int elem_count = 0;
list<string,allocator>::iterator ibegin = textlines.begin(),
iend = textlines.end();
// obsolete form of count()
count( ibegin, iend, search_item, elem_count );
cout << "count(): " << search_item
<< " occurs " << elem_count << " times\n";
return 0;
}
/* to protect file being unlinked from getting lost we "safe" link files
being unlinked. This link will be deleted in the same transaction with last
item of file. mounting the filesytem we scan all these links and remove
files which almost got lost */
void add_save_link (struct reiserfs_transaction_handle * th,
struct inode * inode, int truncate)
{
INITIALIZE_PATH (path);
int retval;
struct cpu_key key;
struct item_head ih;
__u32 link;
/* file can only get one "save link" of each kind */
RFALSE( truncate &&
( inode -> u.reiserfs_i.i_flags & i_link_saved_truncate_mask ),
"saved link already exists for truncated inode %lx",
( long ) inode -> i_ino );
RFALSE( !truncate &&
( inode -> u.reiserfs_i.i_flags & i_link_saved_unlink_mask ),
"saved link already exists for unlinked inode %lx",
( long ) inode -> i_ino );
/* setup key of "save" link */
key.version = KEY_FORMAT_3_5;
key.on_disk_key.k_dir_id = MAX_KEY_OBJECTID;
key.on_disk_key.k_objectid = inode->i_ino;
if (!truncate) {
/* unlink, rmdir, rename */
set_cpu_key_k_offset (&key, 1 + inode->i_sb->s_blocksize);
set_cpu_key_k_type (&key, TYPE_DIRECT);
/* item head of "safe" link */
make_le_item_head (&ih, &key, key.version, 1 + inode->i_sb->s_blocksize, TYPE_DIRECT,
4/*length*/, 0xffff/*free space*/);
} else {
/* truncate */
if (S_ISDIR (inode->i_mode))
reiserfs_warning("green-2102: Adding a truncate savelink for a directory %k! Please report\n", INODE_PKEY(inode));
set_cpu_key_k_offset (&key, 1);
set_cpu_key_k_type (&key, TYPE_INDIRECT);
/* item head of "safe" link */
make_le_item_head (&ih, &key, key.version, 1, TYPE_INDIRECT,
4/*length*/, 0/*free space*/);
}
key.key_length = 3;
/* look for its place in the tree */
retval = search_item (inode->i_sb, &key, &path);
if (retval != ITEM_NOT_FOUND) {
if ( retval != -ENOSPC )
reiserfs_warning ("vs-2100: add_save_link:"
"search_by_key (%K) returned %d\n", &key, retval);
pathrelse (&path);
return;
}
/* body of "save" link */
link = cpu_to_le32 (INODE_PKEY (inode)->k_dir_id);
/* put "save" link inot tree */
retval = reiserfs_insert_item (th, &path, &key, &ih, (char *)&link);
if (retval) {
if (retval != -ENOSPC)
reiserfs_warning ("vs-2120: add_save_link: insert_item returned %d\n",
retval);
} else {
if( truncate )
inode -> u.reiserfs_i.i_flags |= i_link_saved_truncate_mask;
else
inode -> u.reiserfs_i.i_flags |= i_link_saved_unlink_mask;
}
}
/* look for uncompleted unlinks and truncates and complete them */
static void finish_unfinished (struct super_block * s)
{
INITIALIZE_PATH (path);
struct cpu_key max_cpu_key, obj_key;
struct key save_link_key;
int retval;
struct item_head * ih;
struct buffer_head * bh;
int item_pos;
char * item;
int done;
struct inode * inode;
int truncate;
/* compose key to look for "save" links */
max_cpu_key.version = KEY_FORMAT_3_5;
max_cpu_key.on_disk_key = MAX_KEY;
max_cpu_key.key_length = 3;
done = 0;
s -> u.reiserfs_sb.s_is_unlinked_ok = 1;
while (1) {
retval = search_item (s, &max_cpu_key, &path);
if (retval != ITEM_NOT_FOUND) {
reiserfs_warning ("vs-2140: finish_unfinished: search_by_key returned %d\n",
retval);
break;
}
bh = get_last_bh (&path);
item_pos = get_item_pos (&path);
if (item_pos != B_NR_ITEMS (bh)) {
reiserfs_warning ("vs-2060: finish_unfinished: wrong position found\n");
break;
}
item_pos --;
ih = B_N_PITEM_HEAD (bh, item_pos);
if (le32_to_cpu (ih->ih_key.k_dir_id) != MAX_KEY_OBJECTID)
/* there are no "save" links anymore */
break;
save_link_key = ih->ih_key;
if (is_indirect_le_ih (ih))
truncate = 1;
else
truncate = 0;
/* reiserfs_iget needs k_dirid and k_objectid only */
item = B_I_PITEM (bh, ih);
obj_key.on_disk_key.k_dir_id = le32_to_cpu (*(__u32 *)item);
obj_key.on_disk_key.k_objectid = le32_to_cpu (ih->ih_key.k_objectid);
obj_key.on_disk_key.u.k_offset_v1.k_offset = 0;
obj_key.on_disk_key.u.k_offset_v1.k_uniqueness = 0;
pathrelse (&path);
inode = reiserfs_iget (s, &obj_key);
if (!inode) {
/* the unlink almost completed, it just did not manage to remove
"save" link and release objectid */
reiserfs_warning ("vs-2180: finish_unfinished: iget failed for %K\n",
&obj_key);
remove_save_link_only (s, &save_link_key, 1);
continue;
}
if (!truncate && inode->i_nlink) {
/* file is not unlinked */
reiserfs_warning ("vs-2185: finish_unfinished: file %K is not unlinked\n",
&obj_key);
remove_save_link_only (s, &save_link_key, 0);
continue;
}
if (truncate && S_ISDIR (inode->i_mode) ) {
/* We got a truncate request for a dir which is impossible.
The only imaginable way is to execute unfinished truncate request
then boot into old kernel, remove the file and create dir with
the same key. */
reiserfs_warning("green-2101: impossible truncate on a directory %k. Please report\n", INODE_PKEY (inode));
remove_save_link_only (s, &save_link_key, 0);
truncate = 0;
iput (inode);
continue;
}
if (truncate) {
inode -> u.reiserfs_i.i_flags |= i_link_saved_truncate_mask;
/* not completed truncate found. New size was committed together
with "save" link */
reiserfs_warning ("Truncating %k to %Ld ..",
INODE_PKEY (inode), inode->i_size);
reiserfs_truncate_file (inode, 0/*don't update modification time*/);
remove_save_link (inode, truncate);
} else {
inode -> u.reiserfs_i.i_flags |= i_link_saved_unlink_mask;
/* not completed unlink (rmdir) found */
reiserfs_warning ("Removing %k..", INODE_PKEY (inode));
/* removal gets completed in iput */
}
iput (inode);
printk ("done\n");
done ++;
}
s -> u.reiserfs_sb.s_is_unlinked_ok = 0;
pathrelse (&path);
if (done)
reiserfs_warning ("There were %d uncompleted unlinks/truncates. "
"Completed\n", done);
}
