#include <const.h>
#include <string.h>
#include <arch/i386.h>
#include <arch/mem.h>
#include <kernel/Ide.h>
#include <kernel/IdeDebug.h>
#include <kernel/IdeTimer.h>
#include <kernel/IdeLow.h>
#include <kernel/keyboard.h>
#include <kernel/kmalloc.h>
#include <kernel/video.h>
#include <kernel/ext2.h>
Go to the source code of this file.
Definition in file ext2.c.
|
|
|
Definition at line 58 of file ext2.c.
00058 { 00059 return(63 +(num_block*spb)); 00060 00061 } |
|
Definition at line 1057 of file ext2.c.
01057 { 01058 struct i_node * ino; 01059 dword i; 01060 word block_file; 01061 char *c=NULL; 01062 int stop=0,ll=0; 01063 dword ino_file; 01064 01065 if (!mount_ext2) 01066 { 01067 kprintf("\n\rUnmounted File System Ext2\n\r"); 01068 return; 01069 } 01070 01071 if (!(ino_file = FindFile(param))) 01072 { 01073 kprintf("\n\rNo such file\n\r"); 01074 return; 01075 } 01076 else if (!(ino=get_inode(ino_file))) 01077 { 01078 // invalid inode number 01079 } 01080 else if (!(isFile(ino)||isFastSymbolicLink(ino))) 01081 { 01082 kprintf("\n\rNot a regular file\n\r"); 01083 return; 01084 } 01085 else if (Open_File(ino,ino->i_mode & MODE_MASK)) 01086 { 01087 // dimensione in blocchi del file 01088 block_file = 0; 01089 stop = 3; 01090 data_block = (byte *)kmalloc(dim_block); 01091 memset(data_block,0,dim_block); 01092 //clrscr(); 01093 set_color(LIGHT_BLUE); 01094 kprintf("filename: %s\n\n\r",param); 01095 set_color(DEFAULT_COLOR); 01096 for (i=0;i<ino->i_size;i++) 01097 { 01098 if (i % dim_block ==0) 01099 { 01100 if ( (err = ReadSectorsLba(0,(int64_t)blocco_to_LBA(ptr_dir[block_file]),spb,(word *)data_block,TRUE)) ) 01101 { 01102 kprintf ("\n\rError reading file data block"); 01103 ShowIdeErrorMessage(err,TRUE); 01104 kfree(ptr_dir); 01105 kfree(data_block); 01106 return; 01107 } 01108 block_file++; 01109 c = (char *)data_block; 01110 } 01111 01112 01113 if (*c==10) // carattere di fine linea 01114 { 01115 stop++; 01116 kprintf("\n\r"); 01117 ll=0; 01118 } 01119 else 01120 { 01121 kputchar(*c); 01122 if(ll++>70) 01123 { 01124 // se la linea eccede in lunghezza la dimensione 01125 //dello schermo si divide in due linee 01126 stop++; 01127 ll = 0; 01128 } 01129 } 01130 01131 c++; 01132 01133 if (((stop)%22)==0) 01134 { 01135 kprintf ("\n\r ------ Continue ------"); 01136 if ( kgetchar()==CTRL_C ) 01137 { 01138 // *** Andrea Righi 2003-10-04 *** // 01139 kfree(data_block); 01140 //********************************// 01141 kprintf("\n\r"); 01142 return; 01143 } 01144 clrscr(); 01145 stop = 3; 01146 set_color(LIGHT_BLUE); 01147 kprintf("filename: %s\n\n\r",param); 01148 set_color(DEFAULT_COLOR); 01149 } 01150 } 01151 kfree(data_block); 01152 } 01153 } |
|
Definition at line 905 of file ext2.c.
00905 { 00906 struct i_node* ino; 00907 int i,j_param,len_param,i_param; 00908 dword ino_dir; 00909 char elem_path[256]; // si usa per il parsing della path 00910 bool errore; 00911 00912 //kprintf("\n\rparam %s",param); 00913 if(!mount_ext2) 00914 { 00915 kprintf("\n\rUnmounted File System Ext2\n\n\r"); 00916 return; 00917 } 00918 00919 if (!strcmp(param,".")) 00920 { 00921 // si rimane nella directory corrente 00922 return; 00923 } 00924 00925 if (!strcmp(param,"/")) 00926 { 00927 // si ritorna alla directory radice 00928 if (!Open_Dir(get_inode(EXT2_ROOT_INO))) 00929 { 00930 // se non si può più aprire la root si smonta il file system 00931 mount_ext2 = FALSE; 00932 return; 00933 } 00934 level = 0; 00935 path_ext2[0]='\0'; 00936 return; 00937 } 00938 00939 00940 if ((level == 0)&&!strcmp(param,"..")) 00941 { 00942 kprintf("\n\rCannot go up from root\n\n\r"); 00943 } 00944 else if ((level ==1)&&!strcmp(param,"..")) 00945 { 00946 // si ritorna alla directory radice 00947 if (!Open_Dir(get_inode(EXT2_ROOT_INO))) 00948 { 00949 // se non si può più aprire la root si smonta il file system 00950 mount_ext2 = FALSE; 00951 return; 00952 } 00953 level = 0; 00954 path_ext2[0]='\0'; 00955 ino_current_dir = EXT2_ROOT_INO; 00956 } 00957 else 00958 { 00959 00960 errore = FALSE; 00961 // dobbiamo effettuare il salvataggio dei componenti 00962 memcpy(&path_ext2_backup,&path_ext2,1024); 00963 //kprintf ("\n\rpath_ext2_backup : %s\n\r",path_ext2_backup); 00964 level_backup = level; 00965 ino_dir_backup = ino_current_dir; 00966 00967 // dobbiamo fare il parsing della path 00968 i_param = 0; 00969 if (param[0]=='.'&¶m[1]=='/') 00970 { 00971 // ./ sta ad indicare restiamo nella dir corrente 00972 // non ha senso riaprirla 00973 i_param = 2; 00974 } 00975 if (param[strlen(param)-1]=='/') 00976 { 00977 len_param = strlen(param)-1; 00978 } 00979 else len_param = strlen(param); 00980 //kprintf ("\n\rlen_param : %u\n\r",len_param); 00981 00982 for (j_param=0;i_param<=len_param;i_param++) 00983 if ((param[i_param]=='/')||i_param==len_param) 00984 { 00985 elem_path[j_param]='\0'; 00986 j_param = 0; 00987 //kprintf ("\n\relem_path : %s\n\r",elem_path); 00988 if (!(ino_dir=FindFile(elem_path))) 00989 { 00990 // non esiste nella directory corrente la sottodirectory param 00991 kprintf("\n\rDirectory no match\n\n\r"); 00992 errore = TRUE; 00993 break; 00994 } 00995 else if (!(ino=get_inode(ino_dir))) 00996 { 00997 // invalid inode number 00998 errore = TRUE; 00999 break; 01000 } 01001 else if (!(isDir(ino)||isFastSymbolicLink(ino))) 01002 { 01003 kprintf("\n\rNot a directory\n\n\r"); 01004 errore = TRUE; 01005 break; 01006 } 01007 else if (!Open_Dir(ino)) 01008 { 01009 if (!isFastSymbolicLink(ino)) 01010 kprintf("\n\rOpen failed\n\n\r"); 01011 errore = TRUE; 01012 break; 01013 } 01014 else 01015 { 01016 // si aggiorna la path salendo nell'albero 01017 if (!strcmp(elem_path,"..")) 01018 { 01019 01020 if (level) 01021 { 01022 level--; 01023 for (i=strlen(path_ext2)-2;path_ext2[i]!='/';i--); 01024 path_ext2[i+1]='\0'; 01025 } 01026 if (!level) 01027 path_ext2[0]='\0'; 01028 } 01029 else 01030 { 01031 strcat(path_ext2,elem_path); 01032 strcat(path_ext2,"/"); 01033 level++; 01034 } 01035 ino_current_dir = ino_dir; 01036 01037 } 01038 } 01039 else elem_path[j_param++] = param[i_param]; 01040 01041 if (errore) 01042 { 01043 // si ripristina la vecchia directory 01044 kprintf("\n\rerrore\n\r"); 01045 level = level_backup; 01046 memcpy(&path_ext2,&path_ext2_backup,1024); 01047 ino_current_dir = ino_dir_backup; 01048 Open_Dir(get_inode(ino_current_dir)); 01049 01050 01051 } 01052 kprintf("\n\r level :%u\n\r",level); 01053 01054 } 01055 } |
|
Definition at line 1205 of file ext2.c.
01205 { 01206 if ((super->s_magic != N_EXT2_NUMERO_MAGICO)&&(super->s_magic != P_EXT2_NUMERO_MAGICO)) 01207 { 01208 kprintf("\n\rNot a valid ext2.\n\r"); 01209 return(FALSE); 01210 } 01211 else return TRUE; 01212 } |
|
Definition at line 756 of file ext2.c.
00756 { 00757 struct date_ext2 d; 00758 dword mg; 00759 00760 ino_time = ino_time / 86400; //(60*60*24) 00761 00762 // tempo in giorni trascorso dal 1/1/1970 00763 00764 mg = ino_time + 1; 00765 00766 // si determina l'anno 00767 for (d.anno=1970;;d.anno++) 00768 { 00769 if ((d.anno % 4)==0) // bisestile 00770 { 00771 if (mg<366) break; 00772 mg -= 366; 00773 } 00774 else 00775 { 00776 if (mg<365) break; 00777 mg -= 365; 00778 } 00779 00780 } 00781 00782 // mg contiene mese e giorno 00783 for (d.mese=1;;d.mese++) 00784 { 00785 00786 if ((d.mese==4)||(d.mese==6)||(d.mese==9)||(d.mese==11)) 00787 { 00788 if (mg<=30) break; 00789 mg -= 30; 00790 } 00791 else if ((d.mese==2)&&(d.anno%4==0)) 00792 { 00793 if (mg<=29) break; 00794 mg -= 29; 00795 } 00796 else if ((d.mese==2)&&(d.anno%4!=0)) 00797 { 00798 if (mg<=28) break; 00799 mg -= 28; 00800 } 00801 else 00802 { 00803 if (mg<=31) break; 00804 mg -= 31; 00805 } 00806 } 00807 00808 d.giorno = mg; 00809 return(d); 00810 00811 } |
|
Definition at line 739 of file ext2.c.
00739 { 00740 struct time_ext2 t; 00741 dword s; 00742 00743 s = ino_time % 86400; 00744 // ora 00745 t.ora = s / 3600; 00746 s -= t.ora*3600; 00747 // minuti 00748 t.minuti = (s / 60); 00749 s -= t.minuti*60; 00750 // secondi 00751 t.secondi = s; 00752 return(t); 00753 00754 } |
|
Definition at line 572 of file ext2.c.
|
|
Definition at line 132 of file ext2.c.
00132 { 00133 00134 if(grp>number_of_groups) 00135 { 00136 kprintf ("\n\rInvalid group descriptor number"); 00137 return NULL; 00138 } 00139 return(&group_desc_table[grp]); 00140 } |
|
Definition at line 275 of file ext2.c.
00275 { 00276 int i; 00277 int pos_inode = -1; 00278 struct i_node new_inode; 00279 00280 // controlliamo la validità dell'inode 00281 if (!i_node_number || i_node_number>super->s_inodes_count) 00282 { 00283 kprintf("\n\rInvalid inode number"); 00284 return(NULL); 00285 } 00286 00287 //kprintf("\n\r inode_number: %u",i_node_number); 00288 00289 // si cerca se l'inode é presente nella tabella 00290 for (i=0; i < (dim_inode_table-free_inode); i++) 00291 if (inode_table[i].i_node_n == i_node_number) 00292 { 00293 // memorizza posizione inode 00294 pos_inode = i; 00295 break; 00296 } 00297 00298 if (pos_inode == -1) 00299 { 00300 // l'elemento non é presente nella cache dobbiamo reperirlo su disco 00301 ReadInode(i_node_number,&new_inode); 00302 //stampa_i(&new_inode); 00303 00304 if (free_inode>0) // ci sono posizioni non utilizzate 00305 { 00306 pos_inode = dim_inode_table - free_inode; 00307 free_inode--; // decremento numero posizioni libere 00308 } 00309 else 00310 { 00311 pos_inode = inode_LRU(); 00312 } 00313 inode_table[pos_inode].inode = new_inode; // inserisco nella tabella 00314 inode_table[pos_inode].i_node_n = i_node_number; // inserisco numero inode 00315 inode_table[pos_inode].ref = 0; // azzero il riferimento 00316 } 00317 00318 // aggiornamento dei riferimenti 00319 for (i=0; i < (dim_inode_table-free_inode); i++) 00320 { 00321 inode_table[i].ref = inode_table[i].ref >> 1; 00322 if (i == pos_inode) 00323 { 00324 inode_table[i].ref = inode_table[i].ref | 0x8000; 00325 } 00326 } 00327 00328 //kprintf ("\n\rinode inserito nella tabella e restituito"); 00329 //kprintf ("\n\rpos_inode %u",pos_inode); 00330 //kprintf ("\n\rinode number %u",inode_table[pos_inode].i_node_n); 00331 //stampa_i(&inode_table[pos_inode].inode); 00332 // restituisco puntatore all'inode cercato 00333 return (&inode_table[pos_inode].inode); 00334 00335 } |
|
Definition at line 1215 of file ext2.c.
01215 { 01216 path_ext2[0] = '\0'; //inizializzazione della path 01217 01218 if (!read_ext2()) 01219 { 01220 //kprintf("\n\rDisk I/O error. Unable to read the super block!!!\n\r"); 01221 return(FALSE); 01222 } 01223 // inizializzazione ext2 a buon fine 01224 01225 if (!check_ext2()) 01226 { 01227 return(FALSE); 01228 } 01229 // ext2 é valido 01230 01231 01232 // calcolo parametri della versione corrente file system 01233 01234 dim_block = 1024 << super->s_log_block_size; //dimensione dei blocchi 01235 01236 dim_frag = 1024 << super->s_log_frag_size; // dimensione dei frammenti 01237 01238 spb = dim_block / SIZE_SEC; //settori per blocco 01239 01240 sbpos = super->s_first_data_block + 1; // posizione del superblocco 01241 01242 bpg = super->s_blocks_per_group; //blocchi per gruppo 01243 01244 gdpb = dim_block / sizeof(struct group_descriptor); // desc di gruppo per blocco 01245 01246 ipb = dim_block / super->s_inode_size; // inodes per blocco dim inode 128 bit 01247 01248 number_of_groups = super->s_inodes_count / super->s_inodes_per_group; // numero gruppi 01249 01250 dir_entries_per_block = dim_block / sizeof(struct dir_ff); //directory per blocco 01251 01252 dim_ptr = dim_block >> 2; // dim del blocco in parole da 32 bit 01253 01254 // informazioni di carattere generale sulla ext2 corrente 01255 kprintf("\n\rExt2 parameters\n\r"); 01256 kprintf("\n\rTotal number of inodes: %u",super->s_inodes_count); 01257 kprintf("\n\rTotal number of block: %u",super->s_blocks_count); 01258 kprintf("\n\rNumber of blocks reserved for the super user: %u",super->s_r_blocks_count); 01259 kprintf("\n\rNumber of groups: %u",number_of_groups); 01260 kprintf("\n\rBlock per group: %u",bpg); 01261 kprintf("\n\rBlock dimension: %u",dim_block); 01262 kprintf("\n\rFragment dimension: %u",dim_frag); 01263 kprintf("\n\rSector per block: %u",spb); 01264 kprintf("\n\rDirectories per block: %u",dir_entries_per_block); 01265 kprintf("\n\rGroup descriptors per block: %u",gdpb); 01266 kprintf("\n\rInodes per group: %u",super->s_inodes_per_group); 01267 kprintf("\n\rFrags per group: %u",super->s_frags_per_group); 01268 kprintf("\n\rInodes per block: %u",ipb); 01269 kprintf("\n\r"); 01270 01271 // inizializzazione tabella dei descrittori di gruppo 01272 if (!init_group_desc_table()) 01273 { 01274 return(FALSE); 01275 } 01276 01277 // inizializzazione tabella degli inode 01278 if (!init_inode_table()) 01279 { 01280 return(FALSE); 01281 } 01282 01283 // dobbiamo leggere l'inode relativo alla directory radice "inode 2 sempre" 01284 01285 if (!Open_Dir(get_inode(EXT2_ROOT_INO))) 01286 { 01287 // kprintf("\n\rNot able to open the root directory\n\r"); 01288 return(FALSE); 01289 } 01290 01291 ino_current_dir = EXT2_ROOT_INO; 01292 01293 mount_ext2 = TRUE; //file system montato 01294 01295 level = 0; // livello nell'albero delle directory, root = 0 01296 01297 return(TRUE); 01298 } |
|
Definition at line 104 of file ext2.c.
00104 { 00105 if(!(group_desc_table = (struct group_descriptor*)kmalloc(sizeof(struct group_descriptor)*number_of_groups))) 00106 { 00107 kprintf ("\n\rImpossible create group descriptor table: out of memory"); 00108 return FALSE; 00109 } 00110 memset(group_desc_table,0,sizeof(struct group_descriptor)*number_of_groups); 00111 00112 data_block = kmalloc(dim_block); 00113 memset(data_block,0,dim_block); 00114 00115 00116 if ( (err = ReadSectorsLba(0,(int64_t)blocco_to_LBA(sbpos),spb,(word *)data_block,TRUE)) ) 00117 { 00118 // si stampa l'errore relativo al fallimento lettura disco 00119 kprintf ("\n\rerror reading group descriptor block"); 00120 ShowIdeErrorMessage(err,TRUE); 00121 return FALSE; 00122 } 00123 memcpy(group_desc_table,data_block, sizeof(struct group_descriptor)*number_of_groups); 00124 00125 kfree(data_block); 00126 00127 return TRUE; 00128 00129 } |
|
Definition at line 233 of file ext2.c.
00233 { 00234 int i; 00235 // la cache degli inode può contenere il 1% degli inode su disco 00236 dim_inode_table = super->s_inodes_count / 100; 00237 if(!(inode_table = (struct i_node_tab*)kmalloc(sizeof(struct i_node_tab)*dim_inode_table))) 00238 { 00239 kprintf("\n\rImpossible create inode table: out of memory"); 00240 return FALSE; 00241 } 00242 memset(inode_table,0,sizeof(struct i_node_tab)*dim_inode_table); 00243 for (i = 0;i < dim_inode_table; i++) 00244 { 00245 inode_table[i].i_node_n = 0; 00246 inode_table[i].ref = 0; 00247 } 00248 // tutti gli elementi della tabella sono liberi 00249 free_inode = dim_inode_table; 00250 //kprintf("\n\rtabella inode creata correttamente"); 00251 return TRUE; 00252 } |
|
Definition at line 177 of file ext2.c.
00177 { 00178 struct group_descriptor* group_desc; 00179 00180 if (!ino || ino>super->s_inodes_count) 00181 { 00182 kprintf ("\n\rinvalid inode number"); 00183 return 0; 00184 } 00185 00186 // il primo inode parte da 1 00187 ino--; 00188 00189 00190 // si cerca il descrittore del gruppo di blocchi in cui si trova l'inode 00191 if (!(group_desc = get_group_desc(ino/super->s_inodes_per_group))) 00192 { 00193 kprintf ("\n\rNot group desc per inode"); 00194 return 0; 00195 } 00196 00197 ino %= super->s_inodes_per_group; 00198 00199 // bg_inode_table punta al primo blocco tabella inode 00200 //kprintf("\n\r%u",group_desc->bg_inode_table+ino/ipb); 00201 return (group_desc->bg_inode_table+ino/ipb); 00202 } |
|
Definition at line 255 of file ext2.c.
00255 { 00256 word lru = 0; 00257 int i; 00258 00259 // l'elemento cercato é quello meno referenziato negli ultimi 00260 // 16 riferimenti in memoria, la variabile ref é a 16 bit 00261 00262 for (i = 1; i<dim_inode_table; i++) 00263 if (inode_table[i].ref < inode_table[lru].ref) 00264 { 00265 lru = i; 00266 } 00267 //kprintf("\n\rci sono passato lru: %u %u",lru,inode_table[lru].ref); 00268 return (lru); 00269 00270 } |
|
Definition at line 562 of file ext2.c.
|
|
Definition at line 356 of file ext2.c.
|
|
Definition at line 346 of file ext2.c.
|
|
Definition at line 825 of file ext2.c.
00825 { 00826 int i; 00827 struct i_node* info_file; 00828 if (mount_ext2){ 00829 00830 clrscr(); 00831 //kprintf("\n\r Total: %u",count_dir); 00832 for (i=0; i<count_dir; i++) 00833 { 00834 00835 info_file = get_inode(inode_dir[i]); 00836 // data e ora di creazione del file 00837 tempo = det_time(info_file->i_ctime); 00838 data = det_date(info_file->i_ctime); 00839 00840 // TODO : fast symbolic link 00841 if ((info_file->i_mode&MODE_MASK)==MODE_LINK) 00842 continue; 00843 switch (info_file->i_mode & MODE_MASK) 00844 { 00845 00846 case MODE_FILE: 00847 set_color(WHITE); 00848 break; 00849 00850 case MODE_DIR: 00851 set_color(LIGHT_BLUE); 00852 break; 00853 00854 case MODE_CDEV: 00855 set_color(LIGHT_GREEN); 00856 break; 00857 00858 case MODE_BDEV: 00859 set_color(LIGHT_RED); 00860 break; 00861 00862 case MODE_FIFO: 00863 set_color(LIGHT_MAGENTA); 00864 break; 00865 00866 case MODE_SOCK: 00867 set_color(LIGHT_CYAN); 00868 break; 00869 00870 case MODE_LINK: 00871 set_color(RED); 00872 break; 00873 00874 } 00875 00876 kprintf("\n\r %s",ext2_file_name[i]); 00877 set_color(DEFAULT_COLOR); 00878 kprintf ("\r (%u)",inode_dir[i]); 00879 set_color(WHITE); 00880 kprintf("\r %u",info_file->i_size); 00881 kprintf("\r %u:%u",tempo.ora,tempo.minuti); 00882 kprintf("\r %u-%u-%u",data.anno,data.mese,data.giorno); 00883 kprintf("\r %u",info_file->i_blocks); 00884 set_color(DEFAULT_COLOR); 00885 if (((i+1)%22)==0) 00886 { 00887 kprintf ("\n\r ------ Continue ------"); 00888 if (kgetchar()==CTRL_C) 00889 { 00890 kprintf("\n\n\r"); 00891 return; 00892 } 00893 clrscr(); 00894 } 00895 } 00896 kprintf("\n\n"); 00897 } 00898 else kprintf("\n\rUnmounted File System Ext2\n\n\r"); 00899 return; 00900 } |
|
Definition at line 585 of file ext2.c.
00585 { 00586 00587 byte *ptr_block; 00588 dword block_dir; // blocchi che compongono la directory 00589 //dword *ptr_dir; // puntatori blocchi disco contenenti la directory 00590 byte *tmp; // memorizza il contenuto della direcotry 00591 int i,len,idx; 00592 struct dir_ff *dir; 00593 00594 00595 //controlliamo se si tratta effettivamente di una directory 00596 00597 if (!(isDir(inode) || isFastSymbolicLink(inode))) 00598 { 00599 return FALSE; 00600 } 00601 00602 // si restituisce la memoria allocata per i campi se già utilizzati 00603 // if (name != NULL) 00604 if (ext2_file_name != NULL) 00605 { 00606 kfree(inode_dir); 00607 kfree(file_type_dir); 00608 kfree(text); 00609 kfree(ext2_file_name); 00610 } 00611 00612 // se tutto va bene si procede all'apertura memorizzando i puntatori 00613 // ai blocchi dati nell'area di memoria puntata da ptr_dir 00614 if (!(Open_File(inode,inode->i_mode & MODE_MASK))) 00615 { 00616 return FALSE; 00617 } 00618 00619 00620 // dimensione in blocchi della directory 00621 block_dir = (inode->i_size + dim_block - 1)/dim_block; 00622 00623 // inserimento nella sezione di memoria tmp dei dati relativi alla directory 00624 tmp = (byte *)kmalloc(inode->i_size); 00625 memset(tmp,0,inode->i_size); 00626 00627 00628 //punta all'inizio dell'area di memoria tmp 00629 ptr_block = (byte *)tmp; 00630 00631 //memset(ptr_block,0,dim_block); 00632 for (i = 0; i<block_dir;i++) 00633 { 00634 //kprintf("\n\rptr_dir[%u]: %u",i,ptr_dir[i]); 00635 if ( (err = ReadSectorsLba(0,(int64_t)blocco_to_LBA(ptr_dir[i]),spb,(word *)ptr_block,TRUE)) ) 00636 { 00637 kprintf ("\n\rError reading data block"); 00638 ShowIdeErrorMessage(err,TRUE); 00639 kfree(ptr_dir); 00640 kfree(tmp); 00641 return FALSE; 00642 } 00643 ptr_block += dim_block; 00644 } 00645 00646 kfree(ptr_dir); 00647 00648 00649 // passo 1 : conteggio elementi della directory 00650 00651 count_dir = 0; // memorizza il numero di elementi della dir 00652 len = 0; 00653 // i si incrementa della dimensione degli elementi della directory 00654 // len si incrementa della lunghezza degli elementi +1 per il fine stringa 00655 // dir punta ad ogni passo alla sequenza di byte di ogni elemento della dir 00656 for (i = 0; i<inode->i_size; ) 00657 { 00658 dir = (struct dir_ff*)&tmp[i]; 00659 if (dir->inode) // se uguale a zero vuol dire non utilizzato 00660 { 00661 //TODO: nel caso in cui non si stampino i fsl 00662 count_dir++; 00663 len += dir->name_len + 1; 00664 } 00665 i += dir->rec_len; 00666 } 00667 00668 // vettore che contiene gli inode dei file nella directory 00669 inode_dir = (dword *)kmalloc(count_dir * sizeof(dword)); 00670 memset(inode_dir,0,count_dir * sizeof(dword)); 00671 // vettore che contiene il tipo dei file nella directory 00672 file_type_dir = (byte *)kmalloc(count_dir); 00673 memset(file_type_dir,0,count_dir); 00674 // nome dei file degli elementi della directory 00675 // *** Andrea Righi 2003-10-03 *********************************// 00676 // name = (char *)kmalloc(count_dir); 00677 // memset(name,0,count_dir); 00678 // ext2_file_name = &name; 00679 //**************************************************************// 00680 ext2_file_name = kmalloc(count_dir*sizeof(char *)); 00681 00682 text = (char *)kmalloc(len); 00683 memset(text,0,len); 00684 00685 // secondo passo si registrano gli elementi 00686 idx = 0; 00687 for (len = i = 0;i<inode->i_size;) 00688 { 00689 dir = (struct dir_ff*)&tmp[i]; 00690 // si memorizzano gli indirizzi degli inode degli elementi 00691 if (dir->inode) 00692 { 00693 inode_dir[idx] = dir->inode; 00694 file_type_dir[idx] = dir->file_type; 00695 // copia dell'elemento di memoria 00696 memcpy(&text[len],dir->name,dir->name_len); 00697 // si azzera l'elemento dopo il nome 00698 text[len+dir->name_len] = '\0'; 00699 //punta al corrispondente nome di file 00700 ext2_file_name[idx++] = &text[len]; 00701 len += dir->name_len + 1; 00702 } 00703 i += dir->rec_len; 00704 } 00705 00706 // si restituisce la memoria occupata da tmp 00707 kfree(tmp); 00708 00709 return TRUE; 00710 } |
|
Definition at line 429 of file ext2.c.
00429 { 00430 00431 int i; 00432 char * fsl; 00433 dword n,m; 00434 dword *ptr; 00435 if (ino == NULL) 00436 { 00437 // si é verificato un errore nessun inode specificato 00438 kprintf ("\n\rInvalid inode\n\r"); 00439 return FALSE; 00440 } 00441 00442 // check di validità dell'inode 00443 if (!(tipo_file == MODE_DIR || tipo_file == MODE_FILE || tipo_file == MODE_LINK)) 00444 { 00445 // tipo non valido 00446 kprintf ("\n\rInvalid file type\n\r"); 00447 return FALSE; 00448 } 00449 00450 // TODO : fast symbolic link 00451 if ((tipo_file==MODE_LINK) && (ino->i_size<64)) 00452 { 00453 kprintf ("\n\rFast symbolic link path : "); 00454 00455 fsl = (byte *)kmalloc(sizeof(struct i_node)); 00456 memset(fsl,0,sizeof(struct i_node)); 00457 memcpy(fsl,ino,sizeof(struct i_node)); 00458 for (i=39;i<(ino->i_size+39);i++) 00459 kprintf("%c",fsl[i]); 00460 kprintf("\n\n\r"); 00461 kfree(fsl); 00462 ptr_dir = (dword *)kmalloc(0); 00463 return FALSE; 00464 } 00465 00466 // lettura di tutti i puntatori ai blocchi dati del file 00467 00468 // numero di blocchi che compongono il file 00469 /*dword*/ n = (ino->i_size+dim_block-1)/dim_block; 00470 00471 // si linearizzano tutti i puntatori ai blocchi dati in modo 00472 // tale da semplificare la struttura gerarchica ed ottimizzare 00473 // l'accesso ai blocchi dati veri e propri 00474 ptr_dir = (dword *)kmalloc(n * sizeof(dword)); 00475 memset(ptr_dir,0,n * sizeof(dword)); 00476 00477 // scorre l'area di memoria 32 bit alla volta 00478 /*dword * */ptr = (dword *)ptr_dir; 00479 00480 // i primi 12 blocchi sono indirizzati direttamente 00481 /*dword*/ m = (n<12) ? n : 12; 00482 00483 // memcpy copia byte per byte perciò m<<2 00484 if (m) memcpy(ptr,ino->i_block,m<<2); 00485 00486 //kprintf("\n\rstampo ptr:%u n:%u m:%u",ptr_dir[0],n,m); 00487 //kgetchar(); 00488 // blocchi puntati indirettamente 00489 n-=m; 00490 // ptr avanza per indirizzare la memoria contenente i blocchi indiretti 00491 ptr += m; 00492 // se ci sono blocchi indiretti si aprono 00493 if (!ReadIndirect1(ptr,&n,ino->i_block[12])) 00494 { 00495 //kprintf ("\n\rind1"); 00496 kfree(ptr_dir); 00497 return FALSE; 00498 } 00499 // indirizzamento indiretto doppio 00500 if (!ReadIndirect2(ptr,&n,ino->i_block[13])) 00501 { 00502 //kprintf ("\n\rind2"); 00503 kfree(ptr_dir); 00504 return FALSE; 00505 } 00506 // indirizzamento indiretto triplo 00507 if(n) 00508 { 00509 //kprintf ("\n\rind3"); 00510 dword* r3 = (dword *)kmalloc(dim_ptr * sizeof(dword)); 00511 // TODO : lettura indirizzamento triplo 00512 if( (err = ReadSectorsLba(0,blocco_to_LBA(ino->i_block[14]),spb,(word *)r3,TRUE)) ) 00513 { 00514 kprintf ("\n\rerror reading third level indirect addressing"); 00515 ShowIdeErrorMessage(err,TRUE); 00516 kfree(r3); 00517 return FALSE; 00518 } 00519 00520 // TODO : ricontrollare la definizione di i indice 00521 for(i = 0; n && i<dim_ptr; i++) 00522 if(!ReadIndirect2(ptr,&n,r3[i])) 00523 { 00524 kfree(ptr_dir); 00525 kfree(r3); 00526 return FALSE; 00527 } 00528 kfree(r3); 00529 } 00530 00531 return TRUE; 00532 // a questo punto ptr_dir contiene il valore dei puntatori ai blocchi 00533 // del file aperto 00534 } |
|
Definition at line 817 of file ext2.c.
00817 { 00818 if (mount_ext2) 00819 return(path_ext2); 00820 else return('\0'); 00821 } |
|
Definition at line 1165 of file ext2.c.
01165 { 01166 01167 int dev,sec; 01168 01169 kprintf ("\n\n\rInitializing Ext2..."); 01170 01171 /* 01172 lettura del superblocco a partire START_SUPER_BLOCK. Il super blocco 01173 si trova sempre nel primo blocco della partizione e occupa esattamente 1024 byte 01174 */ 01175 01176 data_block = kmalloc(DIM_SUPER_BLOCK); 01177 memset(data_block,0,DIM_SUPER_BLOCK); 01178 01179 dev = 0; 01180 sec = 2; 01181 01182 // seleziono il canale 01183 SelectAtaChannel(CC_PRIMARY); 01184 01185 if ( (err = ReadSectorsLba(dev,(int64_t) blocco_to_LBA(0)+sec,2,(word *) data_block,TRUE)) ) 01186 { 01187 // si stampa l'errore relativo al fallimento lettura disco 01188 ShowIdeErrorMessage(err,TRUE); 01189 return FALSE; 01190 } 01191 else { 01192 // si copia il settore nella variabile super 01193 // *** Andrea Righi ****************************// 01194 //! super must be allocated first... 01195 super = kmalloc(sizeof(struct super_block)); 01196 // *********************************************// 01197 memcpy(super,data_block,sizeof(struct super_block)); 01198 return TRUE; 01199 } 01200 kfree(data_block); 01201 } |
|
Definition at line 81 of file ext2.c.
00081 { 00082 00083 if (grp>number_of_groups) 00084 { 00085 return FALSE; 00086 } 00087 00088 return TRUE; 00089 } |
|
Definition at line 366 of file ext2.c.
00366 { 00367 dword* r1; 00368 int m; 00369 // controlliamo se ci sono blocchi puntati indirettamente 00370 if(*cnt<=0) 00371 { 00372 return TRUE; 00373 } 00374 00375 //kprintf("\n\r read indirect 1"); 00376 /* dword* */ r1 = (dword *)kmalloc(dim_ptr * sizeof(dword)); 00377 memset(r1,0,dim_ptr * sizeof(dword)); 00378 // si deve leggere il blocco dati puntato indirettamente 00379 00380 if ( (err = ReadSectorsLba(0,(int64_t)blocco_to_LBA(blk),spb,(word *)r1,TRUE)) ) 00381 { 00382 kprintf ("\n\rerror reading indirect addressing"); 00383 ShowIdeErrorMessage(err,TRUE); 00384 kfree(r1); 00385 return FALSE; 00386 } 00387 00388 /*int*/ m = min(*cnt,dim_ptr); 00389 // se cnt < dim_ptr vuol dire che non tutti gli indici 00390 // dei blocchi del blocco indice sono occupati dal file 00391 memcpy(dst,r1,m<<2); 00392 kfree(r1); 00393 *cnt -= m; 00394 dst += m; 00395 return TRUE; 00396 } |
|
Definition at line 398 of file ext2.c.
00398 { 00399 int i; 00400 dword* r2; 00401 if(*cnt<=0) 00402 { 00403 return TRUE; 00404 } 00405 00406 //kprintf("\n\r read indirect 2"); 00407 /*dword* */ r2 = (dword *)kmalloc(dim_ptr * sizeof(dword)); 00408 if ( (err = ReadSectorsLba(0,(int64_t)blocco_to_LBA(blk),spb,(word *)r2,TRUE)) ) 00409 { 00410 kprintf ("\n\rerror reading second level indirect addressing"); 00411 ShowIdeErrorMessage(err,TRUE); 00412 kfree(r2); 00413 return FALSE; 00414 } 00415 00416 for (i = 0; *cnt && i<dim_ptr; i++) 00417 if(!ReadIndirect1(dst,cnt,r2[i])) 00418 { 00419 kfree(r2); 00420 return FALSE; 00421 } 00422 00423 kfree(r2); 00424 return TRUE; 00425 } |
|
Definition at line 206 of file ext2.c.
00206 { 00207 dword ino_block = Inode2Block(ino); 00208 if (!ino_block) 00209 { 00210 kprintf ("\n\rerror finding inode block"); 00211 return FALSE; 00212 } 00213 00214 data_block = kmalloc(dim_block); 00215 memset(data_block,0,dim_block); 00216 //kprintf("\n\rino_block: %u",ino_block); 00217 // TODO : si deve leggere in data_block il blocco del disco che contiene l'inode 00218 if ( (err = ReadSectorsLba(0,(int64_t)blocco_to_LBA(ino_block),spb,(word *)data_block,TRUE)) ) 00219 { 00220 // errore nella lettura del blocco relativo all'inode 00221 kprintf ("\n\rerror reading inode block"); 00222 ShowIdeErrorMessage(err,TRUE); 00223 return FALSE; 00224 } 00225 // si copia l'inode relativo 00226 memcpy(data,&data_block[((ino-1)%ipb)*sizeof(struct i_node)],sizeof(struct i_node)); 00227 //stampa_i(data); 00228 kfree(data_block); 00229 return TRUE; 00230 } |
|
Definition at line 64 of file ext2.c.
00064 { 00065 00066 kprintf ("\n\n\rid primo blocco bitmap blocchi: %u",bg->bg_block_bitmap); 00067 kprintf ("\n\rid primo blocco bitmap inode: %u",bg->bg_inode_bitmap); 00068 kprintf ("\n\rid primo blocco tabella inode: %u",bg->bg_inode_table); 00069 kgetchar(); 00070 } |
|
Definition at line 162 of file ext2.c.
00162 { 00163 int i; 00164 00165 kprintf ("\n\n\rtipo inode: %X",ino->i_mode & MODE_MASK); 00166 kprintf ("\n\ruser id associato al file: %u",ino->i_uid); 00167 kprintf ("\n\rfile size (byte): %u",ino->i_size); 00168 kprintf ("\n\rnumero blocchi riservati al file: %u",ino->i_blocks); 00169 for (i=0;i<15;i++) 00170 { 00171 kprintf ("\n\rblock[%u]: %u",i,ino->i_block[i]); 00172 } 00173 kgetchar(); 00174 } |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|