fs/ntfs/support.c

   1 /*
   2  *  support.c
   3  *  Specific support functions
   4  *
   5  *  Copyright (C) 1997 Martin von Löwis
   6  *  Copyright (C) 1997 Régis Duchesne
   7  *
   8  */
   9
  10 #ifdef HAVE_CONFIG_H
  11 #include "config.h"
  12 #endif
  13 #include "ntfstypes.h"
  14 #include "struct.h"
  15 #include "support.h"
  16
  17 #include <stdarg.h>
  18 #include <linux/slab.h>
  19 #include <linux/locks.h>
  20 #include <linux/nls.h>
  21 #include "util.h"
  22 #include "inode.h"
  23 #include "macros.h"
  24
  25 static char print_buf[1024];
  26
  27 #ifdef DEBUG
  28 #include "sysctl.h"
  29 #include <linux/kernel.h>
  30
  31 /* Debugging output */
  32 void ntfs_debug(int mask, const char *fmt, ...)
  33 {
  34         va_list ap;
  35
  36         /* Filter it with the debugging level required */
  37         if(ntdebug & mask){
  38                 va_start(ap,fmt);
  39                 strcpy(print_buf, KERN_DEBUG);
  40                 vsprintf(print_buf + 3, fmt, ap);
  41                 printk(print_buf);
  42                 va_end(ap);
  43         }
  44 }
  45
  46 #ifndef ntfs_malloc
  47 /* Verbose kmalloc */
  48 void *ntfs_malloc(int size)
  49 {
  50         void *ret;
  51
  52         ret = kmalloc(size, GFP_KERNEL);
  53         ntfs_debug(DEBUG_MALLOC, "Allocating %x at %p\n", size, ret);
  54
  55         return ret;
  56 }
  57 #endif
  58
  59 #ifndef ntfs_free
  60 /* Verbose kfree() */
  61 void ntfs_free(void *block)
  62 {
  63         ntfs_debug(DEBUG_MALLOC, "Freeing memory at %p\n", block);
  64         kfree(block);
  65 }
  66 #endif
  67 #else
  68 void ntfs_debug(int mask, const char *fmt, ...)
  69 {
  70 }
  71
  72 #ifndef ntfs_malloc
  73 void *ntfs_malloc(int size)
  74 {
  75         return kmalloc(size, GFP_KERNEL);
  76 }
  77 #endif
  78
  79 #ifndef ntfs_free
  80 void ntfs_free(void *block)
  81 {
  82         kfree(block);
  83 }
  84 #endif
  85 #endif /* DEBUG */
  86
  87 void ntfs_bzero(void *s, int n)
  88 {
  89         memset(s, 0, n);
  90 }
  91
  92 /* These functions deliberately return no value. It is dest, anyway,
  93    and not used anywhere in the NTFS code.  */
  94
  95 void ntfs_memcpy(void *dest, const void *src, ntfs_size_t n)
  96 {
  97         memcpy(dest, src, n);
  98 }
  99
 100 void ntfs_memmove(void *dest, const void *src, ntfs_size_t n)
 101 {
 102         memmove(dest, src, n);
 103 }
 104
 105 /* Warn that an error occured. */
 106 void ntfs_error(const char *fmt,...)
 107 {
 108         va_list ap;
 109
 110         va_start(ap, fmt);
 111         strcpy(print_buf, KERN_ERR);
 112         vsprintf(print_buf + 3, fmt, ap);
 113         printk(print_buf);
 114         va_end(ap);
 115 }
 116
 117 int ntfs_read_mft_record(ntfs_volume *vol, int mftno, char *buf)
 118 {
 119         int error;
 120         ntfs_io io;
 121
 122         ntfs_debug(DEBUG_OTHER, "read_mft_record %x\n",mftno);
 123         if(mftno==FILE_MFT)
 124         {
 125                 ntfs_memcpy(buf,vol->mft,vol->mft_recordsize);
 126                 return 0;
 127         }
 128         if(!vol->mft_ino)
 129         {
 130                 printk("ntfs:something is terribly wrong here\n");
 131                 return ENODATA;
 132         }
 133         io.fn_put=ntfs_put;
 134         io.fn_get=0;
 135         io.param=buf;
 136         io.size=vol->mft_recordsize;
 137         error=ntfs_read_attr(vol->mft_ino,vol->at_data,NULL,
 138                              mftno*vol->mft_recordsize,&io);
 139         if(error || (io.size!=vol->mft_recordsize))
 140         {
 141                 ntfs_debug(DEBUG_OTHER, "read_mft_record: read %x failed (%d,%d,%d)\n",
 142                            mftno,error,io.size,vol->mft_recordsize);
 143                 return error?error:ENODATA;
 144         }
 145         ntfs_debug(DEBUG_OTHER, "read_mft_record: finished read %x\n",mftno);
 146         if(!ntfs_check_mft_record(vol,buf))
 147         {
 148                 printk("Invalid MFT record for %x\n",mftno);
 149                 return EINVAL;
 150         }
 151         ntfs_debug(DEBUG_OTHER, "read_mft_record: Done %x\n",mftno);
 152         return 0;
 153 }
 154
 155 int ntfs_getput_clusters(ntfs_volume *vol, int cluster, ntfs_size_t start_offs,
 156          ntfs_io *buf)
 157 {
 158         struct super_block *sb=NTFS_SB(vol);
 159         struct buffer_head *bh;
 160         ntfs_size_t to_copy;
 161         int length=buf->size;
 162         if(buf->do_read)
 163                 ntfs_debug(DEBUG_OTHER, "get_clusters %d %d %d\n",cluster,start_offs,length);
 164         else
 165                 ntfs_debug(DEBUG_OTHER, "put_clusters %d %d %d\n",cluster,start_offs,length);
 166         while(length)
 167         {
 168                 if(!(bh=bread(sb->s_dev,cluster,vol->clustersize)))
 169                 {
 170                         ntfs_debug(DEBUG_OTHER, "%s failed\n", buf->do_read?"Reading":"Writing");
 171                         return EIO;
 172                 }
 173                 to_copy=min(vol->clustersize-start_offs,length);
 174                 lock_buffer(bh);
 175                 if(buf->do_read)
 176                         buf->fn_put(buf,bh->b_data+start_offs,to_copy);
 177                 else
 178                 {
 179                         buf->fn_get(bh->b_data+start_offs,buf,to_copy);
 180                         mark_buffer_dirty(bh,1);
 181                 }
 182                 unlock_buffer(bh);
 183                 length-=to_copy;
 184                 start_offs=0;
 185                 cluster++;
 186                 brelse(bh);
 187         }
 188         return 0;
 189 }
 190
 191 ntfs_time64_t ntfs_now(void)
 192 {
 193         return ntfs_unixutc2ntutc(CURRENT_TIME);
 194 }
 195
 196 /* when printing unicode characters base64, use this table.
 197    It is not strictly base64, but the Linux vfat encoding.
 198    base64 has the disadvantage of using the slash.
 199 */
 200 static char uni2esc[64]=
 201   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+-";
 202
 203 static unsigned char
 204 esc2uni(char c)
 205 {
 206         if(c<'0')return 255;
 207         if(c<='9')return c-'0';
 208         if(c<'A')return 255;
 209         if(c<='Z')return c-'A'+10;
 210         if(c<'a')return 255;
 211         if(c<='z')return c-'a'+36;
 212         if(c=='+')return 62;
 213         if(c=='-')return 63;
 214         return 255;
 215 }
 216
 217 int ntfs_dupuni2map(ntfs_volume *vol, ntfs_u16 *in, int in_len, char **out,
 218   int *out_len)
 219 {
 220         int i,o,val;
 221         char *result,*buf;
 222         struct nls_table* nls=vol->nls_map;
 223
 224         result=ntfs_malloc(in_len+1);
 225         if(!result)return ENOMEM;
 226         *out_len=in_len;
 227         result[in_len]='\0';
 228         for(i=o=0;i<in_len;i++){
 229                 int cl,ch;
 230                 unsigned char* uni_page;
 231                 /* FIXME: byte order */
 232                 cl=in[i] & 0xFF;
 233                 ch=(in[i] >> 8) & 0xFF;
 234                 if(!nls){
 235                         if(!ch){
 236                                 result[o++]=cl;
 237                                 continue;
 238                         }
 239                 }else{
 240                         uni_page=nls->page_uni2charset[ch];
 241                         if(uni_page && uni_page[cl]){
 242                                 result[o++]=uni_page[cl];
 243                                 continue;
 244                         }
 245                 }
 246                 if(!(vol->nct & nct_uni_xlate))goto inval;
 247                 /* realloc */
 248                 buf=ntfs_malloc(*out_len+3);
 249                 if( !buf ) {
 250                         ntfs_free( result );
 251                         return ENOMEM;
 252                 }
 253                 memcpy(buf,result,o);
 254                 ntfs_free(result);
 255                 result=buf;
 256                 *out_len+=3;
 257                 result[o++]=':';
 258                 if(vol->nct & nct_uni_xlate_vfat){
 259                         val=(cl<<8)+ch;
 260                         result[o+2]=uni2esc[val & 0x3f];
 261                         val>>=6;
 262                         result[o+1]=uni2esc[val & 0x3f];
 263                         val>>=6;
 264                         result[o]=uni2esc[val & 0x3f];
 265                         o+=3;
 266                 }else{
 267                         val=(ch<<8)+cl;
 268                         result[o++]=uni2esc[val & 0x3f];
 269                         val>>=6;
 270                         result[o++]=uni2esc[val & 0x3f];
 271                         val>>=6;
 272                         result[o++]=uni2esc[val & 0x3f];
 273                 }
 274         }
 275         *out=result;
 276         return 0;
 277  inval:
 278         ntfs_free(result);
 279         *out=0;
 280         return EILSEQ;
 281 }
 282
 283 int ntfs_dupmap2uni(ntfs_volume *vol, char* in, int in_len, ntfs_u16 **out,
 284   int *out_len)
 285 {
 286         int i,o;
 287         ntfs_u16* result;
 288         struct nls_table* nls=vol->nls_map;
 289
 290         *out=result=ntfs_malloc(2*in_len);
 291         if(!result)return ENOMEM;
 292         *out_len=in_len;
 293         for(i=o=0;i<in_len;i++,o++){
 294                 unsigned short cl,ch;
 295                 if(in[i]!=':' || (vol->nct & nct_uni_xlate)==0){
 296                         cl=nls->charset2uni[(unsigned char)in[i]].uni1;
 297                         ch=nls->charset2uni[(unsigned char)in[i]].uni2;
 298                 }else{
 299                         unsigned char c1,c2,c3;
 300                         *out_len-=3;
 301                         c1=esc2uni(in[++i]);
 302                         c2=esc2uni(in[++i]);
 303                         c3=esc2uni(in[++i]);
 304                         if(c1==255 || c2==255 || c3==255)
 305                                 cl=ch=0;
 306                         else if(vol->nct & nct_uni_xlate_vfat){
 307                                 cl = (c1 << 4) + (c2 >> 2);
 308                                 ch = ((c2 & 0x3) << 6) + c3;
 309                         }else{
 310                                 ch=(c3 << 4) + (c2 >> 2);
 311                                 cl=((c2 & 0x3) << 6) + c1;
 312                         }
 313                 }
 314                 /* FIXME: byte order */
 315                 result[o] = (ch<<8) | cl;
 316                 if(!result[o]){
 317                         ntfs_free(result);
 318                         return EILSEQ;
 319                 }
 320         }
 321         return 0;
 322 }
 323
 324 /*
 325  * Local variables:
 326  * c-file-style: "linux"
 327  * End:
 328  */