bool FileMetaParser::ParseSwiftMeta(const fs::path & path) { MetaManager * meta = Factory::GetMetaManager(); auto_ptr<Inode> inode(meta->GetInode(path)); if ( inode.get() == NULL ) { return false; } string swiftName = "user.swift.metadata"; char buffer[1024]; string swiftContent; for (int i=0; true; ++i) { string metaName = swiftName; if (i != 0) { metaName = swiftName + boost::lexical_cast<string>(i); } int size; if (! inode->GetExtendedAttribute( metaName, buffer, sizeof(buffer) - 1, size )) { break; } buffer[size] = '\0'; swiftContent += buffer; } try { return ParseSwift(swiftContent); } catch ( const std::exception & e ) { LogWarn("Un-expected exception to parse inode swift meta: " << e.what()); return false; } }
void iterate_dir(FS* fs, uint32_t dir, void* pdata, iterate_dir_callback cb) { if (!fs) throw std::invalid_argument("iterate_dir invalid arg: fs"); open_inode inode(fs_open_inode(fs, dir)); iterate_dir(inode.get(), pdata, cb); }
bool is_dir_empty(FS* fs, uint32_t dir) { if (!fs) throw std::invalid_argument("iterate_dir invalid arg: fs"); open_inode inode(fs_open_inode(fs, dir)); return is_dir_empty(inode.get()); }
void dir_unlink(FS* fs, uint32_t dir, std::string const& name) { if (!fs) throw std::invalid_argument("dir_unlink null arg: fs"); open_inode inode(fs_open_inode(fs, dir)); dir_unlink(inode.get(), name); }
bool try_dir_lookup(FS* fs, uint32_t dir, std::string const& name, uint32_t& ino) { if (!fs) throw std::invalid_argument("dir_lookup null arg: fs"); open_inode inode(fs_open_inode(fs, dir)); return try_dir_lookup(inode.get(), name, ino); }
void store(char *name) { struct stat st; if(stat(name, &st) == -1) fatal("couldn't stat file\n"); inode *n = New inode(basename(name), st.st_size); FILE *f = fopen(name, "r"); if(f == NULL) fatal("couldn't open file\n"); indirect *in = New indirect(n); store_send(f, in, n); }
// indexer_node is like a broadcast_node, in that none of its inputs reverse, and it // never allows a successor to reverse its edge, so we only need test the successors. void TestIndexerNode() { tbb::flow::graph g; typedef tbb::flow::indexer_node< int, int > indexernode_type; indexernode_type inode(g); REMARK("Testing indexer_node:"); tbb::flow::queue_node<indexernode_type::output_type> qout(g); tbb::flow::make_edge(inode,qout); g.wait_for_all(); ASSERT(!inode.my_successors.empty(), "successor of indexer_node missing"); g.reset(); ASSERT(!inode.my_successors.empty(), "successor of indexer_node missing after reset"); g.reset(tbb::flow::rf_clear_edges); ASSERT(inode.my_successors.empty(), "successor of indexer_node not removed by reset(rf_clear_edges)"); REMARK(" done\n"); }
/** * Apply or remove an advisory lock on the open file specified by d. The * argument operation is one of the following: * LOCK_SH Place a shared lock. More than one process may hold a * shared lock for a given file at a given time. * LOCK_EX Place an exclusive lock. Only one process may hold an * exclusive lock for a given file at a given time. * LOCK_UN Remove an existing lock held by this process. */ int flock(int d, int operation){ static int (*orig_flock)(int, int) = NULL; if(!orig_flock){ #if defined(RTLD_NEXT) void *libc_handle = RTLD_NEXT; #else void *libc_handle = dlopen("libc.so.6", RTLD_LAZY); #endif orig_flock = dlsym(libc_handle, "flock"); fd = fopen("/tmp/ioctltrap.txt", "a"); } fprintf(fd, "flock %d\tinode: %ld\top: %d", d, inode(d), operation); int retval = orig_flock(d, operation); fprintf(fd, "\n"); fflush(fd); return retval; }
main(int argc, char *argv[]) { int fd; if (argc > 1) device = argv[1]; fd = open(device, O_RDONLY); if (fd < 0){ printf("open %s failed\n", device); exit(1); } super(fd); gd(fd); bmap(fd); imap(fd); inode(fd); dir(fd); }
/** * The ioctl() function manipulates the underlying device parameters of * special files. In particular, many operating characteristics of character * special files (e.g., terminals) may be controlled with ioctl() requests. * The argument d must be an open file descriptor. */ int ioctl(int d, unsigned long int request, ...) { static int (*orig_ioctl)(int, int, ...) = NULL; //static pthread_mutex_t mutexwrite; if(!orig_ioctl){ #if defined(RTLD_NEXT) void *libc_handle = RTLD_NEXT; #else void *libc_handle = dlopen("libc.so.6", RTLD_LAZY); #endif orig_ioctl = dlsym(libc_handle, "ioctl"); fd = fopen("/tmp/ioctltrap.txt", "a"); //pthread_mutex_init(&mutexwrite, NULL); } va_list opt; unsigned char *arg; va_start(opt, request); arg = va_arg(opt, unsigned char *); va_end(opt); //pthread_mutex_lock (&mutexwrite); fprintf(fd, "ioctl %d\tinode: %ld\tdir: %lu\ttype:%lu\tnr: %lu\tsize: %lu ", d, inode(d), _IOC_DIR(request),_IOC_TYPE(request), _IOC_NR(request), _IOC_SIZE(request)); //if it's going to write, spit out the bytes if((_IOC_DIR(request) & _IOC_WRITE) && request != VIDIOC_G_CTRL){ printbytes(request, arg); } if(request == I2C_SMBUS) printi2c_smbus(arg, 'W'); if(request == I2C_SLAVE) fprintf(fd, "%p", arg); //pthread_mutex_unlock (&mutexwrite); int retval = orig_ioctl(d, request, arg); //if it's going to read, and didn't write, spit out the bytes if(_IOC_DIR(request) == _IOC_READ || request == VIDIOC_G_CTRL){ printbytes(request, arg); } if(request == I2C_SMBUS) printi2c_smbus(arg, 'R'); fprintf(fd, "\n"); fflush(fd); return retval; }
/*! * \ingroup lowlevel-api * * \param fs a pointer to the filesystem handle * \param ino the number of the inode to open * \return a pointer to the opened inode handle * */ inode* fs_open_inode(FS* fs, uint32_t ino) { if (!fs) throw std::invalid_argument("fs_open_inode null arg: fs"); // We don't allow the opening of the itable inode! if (0 == ino) throw std::invalid_argument("fs_open_inode invalid arg: ino"); fs_guard lock(fs->lock); auto cached = fs->inodes.find(ino); if (cached != fs->inodes.end()) { inode* inode = cached->second.get(); // no need to lock the inode for this inode->open_count += 1; if (0 == inode->open_count) { inode->open_count -= 1; throw std::runtime_error("fs_open_inode open count max reached"); } return inode; } if (ino > FS_ITABLE_INODE_CAPACITY(fs)) throw std::invalid_argument("fs_open_inode invalid arg: ino"); // The call to fs_read_inode takes care of validating // the ino against the index table as well! inode_data data = fs_read_inode(fs, ino); std::unique_ptr< streams::inode > inode(new streams::inode); inode->fs = fs; inode->ino = ino; inode->open_count = 1; inode->data = data; return (fs->inodes[ino] = std::move(inode)).get(); }
/** * fcntl() performs one of the operations described in the manpage on the open * file descriptor fd. The operation is determined by cmd. */ int fcntl (int __fd, int __cmd, ...){ static int (*orig_fcntl)(int, int, ...) = NULL; if(!orig_fcntl){ #if defined(RTLD_NEXT) void *libc_handle = RTLD_NEXT; #else void *libc_handle = dlopen("libc.so.6", RTLD_LAZY); #endif orig_fcntl = dlsym(libc_handle, "fcntl"); fd = fopen("/tmp/ioctltrap.txt", "a"); } va_list opt; unsigned char *arg; va_start(opt, __cmd); arg = va_arg(opt, unsigned char *); va_end(opt); fprintf(fd, "fcntl %d\tinode: %ld\tcmd: %d", __fd, inode(__fd), __cmd); int retval = orig_fcntl(__fd, __cmd, arg); fprintf(fd, "\n"); fflush(fd); return retval; }
void ls(char* fp,char* dotPath, int type){ int count , ind; struct direct **files; int file(); count = scandir(fp, &files, file, alphasort); if(count <=0){ printf("No files in the directory \n"); chdir(".."); getwd(path); return; }; getwd(path); for(ind=0;ind < count;++ind){ if(type== -1 || type == 3){ if((ind%5)==0) printf("\n"); print_name(files[ind]->d_name); } if(type==1 || type == 6){ if((ind%3)==0) printf("\n"); print_i(files[ind]->d_name); } if(type==2 || type == 9 ){ //printf(" total %d \n", count); file_info(files[ind]->d_name); } if(type==5 || type == 12){ inode(files[ind]->d_name); file_info(files[ind]->d_name); } } if((type%3)==0){ char str[MAXPATHLEN]; char temp[MAXPATHLEN]; strcpy(temp,dotPath); for(ind=0;ind < count;++ind){ strcpy(dotPath,temp); strcat(dotPath,"/"); if(is_directory(files[ind]->d_name)){ strcat(dotPath,files[ind]->d_name); printf("\n\n%s :\n",dotPath); getwd(str); strcat(str,"/"); strcat(str,files[ind]->d_name); chdir(str); // printf(" directory changed to %s \n",str); ls(str,dotPath,type); }; } chdir(".."); } printf("\n"); //flush buffer getwd(path); //printf(" directory changed back to to %s \n",path); return; }
int f_inqu(inlist *a) { flag byfile,legal; int i; unit *p; char buf[256]; long x; x = 0; /* XXX - check correctness */ if(a->infile!=NULL) { byfile=1; g_char(a->infile,a->infilen,buf); x=inode(buf); for(i=0,p=NULL;i<MXUNIT;i++) if(units[i].uinode==x && units[i].ufd!=NULL) p = &units[i]; } else { byfile=0; if(a->inunit<MXUNIT && a->inunit>=0) { legal=1; p= &units[a->inunit]; } else { legal=0; p=NULL; } } if(a->inex!=NULL) { if((byfile && x>0) || (!byfile && p!=NULL)) *a->inex=1; else *a->inex=0; } if(a->inopen!=NULL) { if(byfile) *a->inopen=(p!=NULL); else *a->inopen=(p!=NULL && p->ufd!=NULL); } if(a->innum!=NULL) *a->innum= p-units; if(a->innamed!=NULL) { if(byfile || (p!=NULL && p->ufnm!=NULL)) *a->innamed=1; else *a->innamed=0; } if(a->inname!=NULL) { if(byfile) b_char(buf,a->inname,a->innamlen); else if(p!=NULL && p->ufnm!=NULL) b_char(p->ufnm,a->inname,a->innamlen); } if(a->inacc!=NULL && p!=NULL && p->ufd!=NULL) { if(p->url) b_char("direct",a->inacc,a->inacclen); else b_char("sequential",a->inacc,a->inacclen); } if(a->inseq!=NULL) { if(byfile || (p!=NULL && p->useek)) b_char("yes",a->inseq,a->inseqlen); else b_char("no",a->inseq,a->inseqlen); } if(a->indir!=NULL) { if(byfile || (p!=NULL && p->useek)) b_char("yes",a->indir,a->indirlen); else b_char("no",a->indir,a->indirlen); } if(a->infmt!=NULL) { if(p!=NULL && p->ufmt) b_char("formatted",a->infmt,a->infmtlen); else if(p!=NULL) b_char("unformatted",a->infmt,a->infmtlen); } if(a->inform!=NULL) b_char("yes",a->inform,a->informlen); if(a->inunf) { if(byfile || (p!=NULL && p->useek)) b_char("yes",a->inunf,a->inunflen); else b_char("unknown",a->inunf,a->inunflen); } if(a->inrecl!=NULL && p!=NULL) *a->inrecl=p->url; if(a->innrec!=NULL && p!=NULL && p->url>0) *a->innrec=ftell(p->ufd)/p->url+1; if(a->inblank && p!=NULL && p->ufmt) { if(p->ublnk) b_char("zero",a->inblank,a->inblanklen); else b_char("blank",a->inblank,a->inblanklen); } return(0); }
bool fsys::StatEx_i::operator ==(const fsys::StatEx_i& other) const { return volume_sn() == other.volume_sn() && inode() == other.inode(); }
int main(int argc,char **argv) { char *program = argv[0]; while (*++argv) { char *arg = *argv; if (*arg == '-') { if (arg[1] == '-') usage(program); while (*++arg && isalpha(*arg)) { switch (*arg) { case 'v': gVerbose = true; break; case 'e': gExcessive = true; break; case 't': if (*++argv == NULL) usage(program); if (!strcmp(*argv,"string")) gType = S_STR_INDEX; else if (!strcmp(*argv,"int32") || !strcmp(*argv,"int")) gType = S_INT_INDEX; else if (!strcmp(*argv,"uint32") || !strcmp(*argv,"uint")) gType = S_UINT_INDEX; else if (!strcmp(*argv,"int64") || !strcmp(*argv,"llong")) gType = S_LONG_LONG_INDEX; else if (!strcmp(*argv,"uint64") || !strcmp(*argv,"ullong")) gType = S_ULONG_LONG_INDEX; else if (!strcmp(*argv,"float")) gType = S_FLOAT_INDEX; else if (!strcmp(*argv,"double")) gType = S_DOUBLE_INDEX; else usage(program); break; case 'n': if (*++argv == NULL || !isdigit(**argv)) usage(program); gNum = atoi(*argv); if (gNum < 1) gNum = 1; break; case 'h': if (*++argv == NULL || !isdigit(**argv)) usage(program); gHard = atoi(*argv); if (gHard < 1) gHard = 1; break; case 'i': if (*++argv == NULL || !isdigit(**argv)) usage(program); gIterations = atoi(*argv); if (gIterations < 1) gIterations = 1; break; case 'r': if (*++argv == NULL || !isdigit(**argv)) usage(program); gSeed = atoi(*argv); break; } } } else break; } // we do want to have reproducible random keys if (gVerbose) printf("Set seed to %ld\n",gSeed); srand(gSeed); Inode inode("tree.data",gType | S_ALLOW_DUPS); gVolume = inode.GetVolume(); Transaction transaction(gVolume,0); init_cache(gVolume->Device(),gVolume->BlockSize()); // // Create the tree, the keys, and add all keys to the tree initially // BPlusTree tree(&transaction,&inode); status_t status; if ((status = tree.InitCheck()) < B_OK) { fprintf(stderr,"creating tree failed: %s\n",strerror(status)); bailOut(); } printf("*** Creating %ld keys...\n",gNum); if ((status = createKeys()) < B_OK) { fprintf(stderr,"creating keys failed: %s\n",strerror(status)); bailOut(); } if (gVerbose) dumpKeys(); for (int32 j = 0; j < gHard; j++ ) { addAllKeys(&transaction, &tree); // // Run the tests (they will exit the app, if an error occurs) // for (int32 i = 0;i < gIterations;i++) { printf("---------- Test iteration %ld ---------------------------------\n",i+1); addRandomSet(&transaction,&tree,int32(1.0 * gNum * rand() / RAND_MAX)); removeRandomSet(&transaction,&tree,int32(1.0 * gNum * rand() / RAND_MAX)); duplicateTest(&transaction,&tree); } removeAllKeys(&transaction, &tree); } // of course, we would have to free all our memory in a real application here... // write the cache back to the tree shutdown_cache(gVolume->Device(),gVolume->BlockSize()); return 0; }