fs/fat/file.c

   1 /*
   2  *  linux/fs/fat/file.c
   3  *
   4  *  Written 1992,1993 by Werner Almesberger
   5  *
   6  *  regular file handling primitives for fat-based filesystems
   7  */
   8
   9 #define ASC_LINUX_VERSION(V, P, S)      (((V) * 65536) + ((P) * 256) + (S))
  10 #include <linux/version.h>
  11 #include <linux/sched.h>
  12 #include <linux/locks.h>
  13 #include <linux/fs.h>
  14 #include <linux/msdos_fs.h>
  15 #include <linux/errno.h>
  16 #include <linux/fcntl.h>
  17 #include <linux/stat.h>
  18 #include <linux/string.h>
  19 #include <linux/pagemap.h>
  20 #include <linux/fat_cvf.h>
  21
  22 #include <asm/uaccess.h>
  23 #include <asm/system.h>
  24
  25 #include "msbuffer.h"
  26
  27 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
  28 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
  29
  30 #define PRINTK(x)
  31 #define Printk(x) printk x
  32
  33 static struct file_operations fat_file_operations = {
  34         NULL,                   /* lseek - default */
  35         fat_file_read,          /* read */
  36         fat_file_write,         /* write */
  37         NULL,                   /* readdir - bad */
  38         NULL,                   /* select v2.0.x/poll v2.1.x - default */
  39         NULL,                   /* ioctl - default */
  40         generic_file_mmap,      /* mmap */
  41         NULL,                   /* no special open is needed */
  42         NULL,                   /* flush */
  43         NULL,                   /* release */
  44         file_fsync              /* fsync */
  45 };
  46
  47 struct inode_operations fat_file_inode_operations = {
  48         &fat_file_operations,   /* default file operations */
  49         NULL,                   /* create */
  50         NULL,                   /* lookup */
  51         NULL,                   /* link */
  52         NULL,                   /* unlink */
  53         NULL,                   /* symlink */
  54         NULL,                   /* mkdir */
  55         NULL,                   /* rmdir */
  56         NULL,                   /* mknod */
  57         NULL,                   /* rename */
  58         NULL,                   /* readlink */
  59         NULL,                   /* follow_link */
  60         generic_readpage,       /* readpage */
  61         NULL,                   /* writepage */
  62         fat_bmap,               /* bmap */
  63         fat_truncate,           /* truncate */
  64         NULL,                   /* permission */
  65         NULL                    /* smap */
  66 };
  67
  68 /* #Specification: msdos / special devices / mmap
  69         Mmapping does work because a special mmap is provide in that case.
  70         Note that it is much less efficient than the generic_file_mmap normally
  71         used since it allocate extra buffer. generic_file_mmap is used for
  72         normal device (512 bytes hardware sectors).
  73 */
  74 static struct file_operations fat_file_operations_1024 = {
  75         NULL,                   /* lseek - default */
  76         fat_file_read,          /* read */
  77         fat_file_write,         /* write */
  78         NULL,                   /* readdir - bad */
  79         NULL,                   /* select v2.0.x/poll v2.1.x - default */
  80         NULL,                   /* ioctl - default */
  81         fat_mmap,               /* mmap */
  82         NULL,                   /* no special open is needed */
  83         NULL,                   /* flush */
  84         NULL,                   /* release */
  85         file_fsync              /* fsync */
  86 };
  87
  88 /* #Specification: msdos / special devices / swap file
  89         Swap file can't work on special devices with a large sector
  90         size (1024 bytes hard sector). Those devices have a weird
  91         MS-DOS filesystem layout. Generally a single hardware sector
  92         may contain 2 unrelated logical sector. This mean that there is
  93         no easy way to do a mapping between disk sector of a file and virtual
  94         memory. So swap file is difficult (not available right now)
  95         on those devices. Off course, Ext2 does not have this problem.
  96 */
  97 struct inode_operations fat_file_inode_operations_1024 = {
  98         &fat_file_operations_1024,      /* default file operations */
  99         NULL,                   /* create */
 100         NULL,                   /* lookup */
 101         NULL,                   /* link */
 102         NULL,                   /* unlink */
 103         NULL,                   /* symlink */
 104         NULL,                   /* mkdir */
 105         NULL,                   /* rmdir */
 106         NULL,                   /* mknod */
 107         NULL,                   /* rename */
 108         NULL,                   /* readlink */
 109         NULL,                   /* follow_link */
 110         generic_readpage,       /* readpage */
 111         NULL,                   /* writepage */
 112         NULL,                   /* bmap */
 113         fat_truncate,           /* truncate */
 114         NULL,                   /* permission */
 115         NULL                    /* smap */
 116 };
 117
 118 static struct file_operations fat_file_operations_readpage = {
 119         NULL,                   /* lseek - default */
 120         fat_file_read,          /* read */
 121         fat_file_write,         /* write */
 122         NULL,                   /* readdir - bad */
 123         NULL,                   /* select v2.0.x/poll v2.1.x - default */
 124         NULL,                   /* ioctl - default */
 125         generic_file_mmap,      /* mmap */
 126         NULL,                   /* no special open is needed */
 127         NULL,                   /* flush */
 128         NULL,                   /* release */
 129         file_fsync              /* fsync */
 130 };
 131
 132 struct inode_operations fat_file_inode_operations_readpage = {
 133         &fat_file_operations_readpage,  /* default file operations */
 134         NULL,                   /* create */
 135         NULL,                   /* lookup */
 136         NULL,                   /* link */
 137         NULL,                   /* unlink */
 138         NULL,                   /* symlink */
 139         NULL,                   /* mkdir */
 140         NULL,                   /* rmdir */
 141         NULL,                   /* mknod */
 142         NULL,                   /* rename */
 143         NULL,                   /* readlink */
 144         NULL,                   /* follow_link */
 145         fat_readpage,           /* readpage */
 146         NULL,                   /* writepage */
 147         NULL,                   /* bmap */
 148         fat_truncate,           /* truncate */
 149         NULL,                   /* permission */
 150         NULL                    /* smap */
 151 };
 152
 153 #define MSDOS_PREFETCH  32
 154 struct fat_pre {
 155         int file_sector;/* Next sector to read in the prefetch table */
 156                         /* This is relative to the file, not the disk */
 157         struct buffer_head *bhlist[MSDOS_PREFETCH];     /* All buffers needed */
 158         int nblist;     /* Number of buffers in bhlist */
 159         int nolist;     /* index in bhlist */
 160 };
 161 /*
 162         Order the prefetch of more sectors.
 163 */
 164 static void fat_prefetch (
 165         struct inode *inode,
 166         struct fat_pre *pre,
 167         int nb)         /* How many must we prefetch at once */
 168 {
 169         struct super_block *sb = inode->i_sb;
 170         struct buffer_head *bhreq[MSDOS_PREFETCH];      /* Buffers not */
 171                                                         /* already read */
 172         int nbreq = 0;                  /* Number of buffers in bhreq */
 173         int i;
 174         for (i=0; i<nb; i++){
 175                 int sector = fat_smap(inode,pre->file_sector);
 176                 if (sector != 0){
 177                         struct buffer_head *bh;
 178                         PRINTK (("fsector2 %d -> %d\n",pre->file_sector-1,sector));
 179                         pre->file_sector++;
 180                         bh = fat_getblk(sb, sector);
 181                         if (bh == NULL) break;
 182                         pre->bhlist[pre->nblist++] = bh;
 183                         if (!fat_is_uptodate(sb,bh))
 184                                 bhreq[nbreq++] = bh;
 185                 }else{
 186                         break;
 187                 }
 188         }
 189         if (nbreq > 0) fat_ll_rw_block (sb,READ,nbreq,bhreq);
 190         for (i=pre->nblist; i<MSDOS_PREFETCH; i++) pre->bhlist[i] = NULL;
 191 }
 192
 193 /*
 194         Read a file into user space
 195 */
 196 static ssize_t fat_file_read_text(
 197         struct file *filp,
 198         char *buf,
 199         size_t count,
 200         loff_t *ppos)
 201 {
 202         struct inode *inode = filp->f_dentry->d_inode;
 203         struct super_block *sb = inode->i_sb;
 204         char *start = buf;
 205         char *end   = buf + count;
 206         int i;
 207         int left_in_file;
 208         struct fat_pre pre;
 209
 210
 211         if (!inode) {
 212                 printk("fat_file_read: inode = NULL\n");
 213                 return -EINVAL;
 214         }
 215         /* S_ISLNK allows for UMSDOS. Should never happen for normal MSDOS */
 216         if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) {
 217                 printk("fat_file_read: mode = %07o\n",inode->i_mode);
 218                 return -EINVAL;
 219         }
 220         if (*ppos >= inode->i_size || count == 0) return 0;
 221         /*
 222                 Tell the buffer cache which block we expect to read in advance
 223                 Since we are limited with the stack, we preread only MSDOS_PREFETCH
 224                 because we have to keep the result into the local
 225                 arrays pre.bhlist and bhreq.
 226
 227                 Each time we process one block in bhlist, we replace
 228                 it by a new prefetch block if needed.
 229         */
 230         PRINTK (("#### ino %ld pos %ld size %ld count %d\n",inode->i_ino,*ppos,inode->i_size,count));
 231         {
 232                 /*
 233                         We must prefetch complete block, so we must
 234                         take in account the offset in the first block.
 235                 */
 236                 int count_max = (*ppos & (SECTOR_SIZE-1)) + count;
 237                 int   to_reada; /* How many block to read all at once */
 238                 pre.file_sector = *ppos >> SECTOR_BITS;
 239                 to_reada = count_max / SECTOR_SIZE;
 240                 if (count_max & (SECTOR_SIZE-1)) to_reada++;
 241                 if (filp->f_reada || !MSDOS_I(inode)->i_binary){
 242                         /* Doing a read ahead on ASCII file make sure we always */
 243                         /* read enough, since we don't know how many blocks */
 244                         /* we really need */
 245                         int ahead = read_ahead[MAJOR(inode->i_dev)];
 246                         PRINTK (("to_reada %d ahead %d\n",to_reada,ahead));
 247                         if (ahead == 0) ahead = 8;
 248                         to_reada += ahead;
 249                 }
 250                 if (to_reada > MSDOS_PREFETCH) to_reada = MSDOS_PREFETCH;
 251                 pre.nblist = 0;
 252                 fat_prefetch (inode,&pre,to_reada);
 253         }
 254         pre.nolist = 0;
 255         PRINTK (("count %d ahead %d nblist %d\n",count,read_ahead[MAJOR(inode->i_dev)],pre.nblist));
 256         while ((left_in_file = inode->i_size - *ppos) > 0
 257                 && buf < end){
 258                 struct buffer_head *bh = pre.bhlist[pre.nolist];
 259                 char *data;
 260                 int size,offset;
 261                 if (bh == NULL) break;
 262                 pre.bhlist[pre.nolist] = NULL;
 263                 pre.nolist++;
 264                 if (pre.nolist == MSDOS_PREFETCH/2){
 265                         memcpy (pre.bhlist,pre.bhlist+MSDOS_PREFETCH/2
 266                                 ,(MSDOS_PREFETCH/2)*sizeof(pre.bhlist[0]));
 267                         pre.nblist -= MSDOS_PREFETCH/2;
 268                         fat_prefetch (inode,&pre,MSDOS_PREFETCH/2);
 269                         pre.nolist = 0;
 270                 }
 271                 PRINTK (("file_read pos %ld nblist %d %d %d\n",*ppos,pre.nblist,pre.fetched,count));
 272                 wait_on_buffer(bh);
 273                 if (!fat_is_uptodate(sb,bh)){
 274                         /* read error  ? */
 275                         fat_brelse (sb, bh);
 276                         break;
 277                 }
 278                 offset = *ppos & (SECTOR_SIZE-1);
 279                 data = bh->b_data + offset;
 280                 size = MIN(SECTOR_SIZE-offset,left_in_file);
 281                 if (MSDOS_I(inode)->i_binary) {
 282                         size = MIN(size,end-buf);
 283                         copy_to_user(buf,data,size);
 284                         buf += size;
 285                         *ppos += size;
 286                 }else{
 287                         for (; size && buf < end; size--) {
 288                                 char ch = *data++;
 289                                 ++*ppos;
 290                                 if (ch == 26){
 291                                         *ppos = inode->i_size;
 292                                         break;
 293                                 }else if (ch != '\r'){
 294                                         put_user(ch,buf++);
 295                                 }
 296                         }
 297                 }
 298                 fat_brelse(sb, bh);
 299         }
 300         PRINTK (("--- %d -> %d\n",count,(int)(buf-start)));
 301         for (i=0; i<pre.nblist; i++)
 302                 fat_brelse (sb, pre.bhlist[i]);
 303         if (start == buf)
 304                 return -EIO;
 305         if (!IS_RDONLY(inode))
 306                 inode->i_atime = CURRENT_TIME;
 307         filp->f_reada = 1;      /* Will be reset if a lseek is done */
 308         return buf-start;
 309 }
 310
 311 ssize_t fat_file_read(
 312         struct file *filp,
 313         char *buf,
 314         size_t count,
 315         loff_t *ppos)
 316 {
 317         struct inode *inode = filp->f_dentry->d_inode;
 318         if (MSDOS_SB(inode->i_sb)->cvf_format &&
 319             MSDOS_SB(inode->i_sb)->cvf_format->cvf_file_read)
 320                 return MSDOS_SB(inode->i_sb)->cvf_format
 321                         ->cvf_file_read(filp,buf,count,ppos);
 322
 323         /*
 324          * MS-DOS filesystems with a blocksize > 512 may have blocks
 325          * spread over several hardware sectors (unaligned), which
 326          * is not something the generic routines can (or would want
 327          * to) handle).
 328          */
 329         if (!MSDOS_I(inode)->i_binary || inode->i_sb->s_blocksize > 512)
 330                 return fat_file_read_text(filp, buf, count, ppos);
 331         return generic_file_read(filp, buf, count, ppos);
 332 }
 333 /*
 334         Write to a file either from user space
 335 */
 336 ssize_t fat_file_write(
 337         struct file *filp,
 338         const char *buf,
 339         size_t count,
 340         loff_t *ppos)
 341 {
 342         struct inode *inode = filp->f_dentry->d_inode;
 343         struct super_block *sb = inode->i_sb;
 344         int sector,offset,size,left,written;
 345         int error,carry;
 346         const char *start;
 347         char *to,ch;
 348         struct buffer_head *bh;
 349         int binary_mode = MSDOS_I(inode)->i_binary;
 350
 351         PRINTK(("fat_file_write: dentry=%p, inode=%p, ino=%ld\n",
 352                 filp->f_dentry, inode, inode->i_ino));
 353         if (!inode) {
 354                 printk("fat_file_write: inode = NULL\n");
 355                 return -EINVAL;
 356         }
 357         if (MSDOS_SB(sb)->cvf_format &&
 358             MSDOS_SB(sb)->cvf_format->cvf_file_write)
 359                 return MSDOS_SB(sb)->cvf_format
 360                         ->cvf_file_write(filp,buf,count,ppos);
 361
 362         /* S_ISLNK allows for UMSDOS. Should never happen for normal MSDOS */
 363         if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) {
 364                 printk("fat_file_write: mode = %07o\n",inode->i_mode);
 365                 return -EINVAL;
 366         }
 367         /* system files may be immutable */
 368         if (IS_IMMUTABLE(inode))
 369                 return -EPERM;
 370 /*
 371  * ok, append may not work when many processes are writing at the same time
 372  * but so what. That way leads to madness anyway.
 373  */
 374         if (filp->f_flags & O_APPEND)
 375                 *ppos = inode->i_size;
 376         if (count == 0)
 377                 return 0;
 378         error = carry = 0;
 379         for (start = buf; count || carry; count -= size) {
 380                 while (!(sector = fat_smap(inode,*ppos >> SECTOR_BITS)))
 381                         if ((error = fat_add_cluster(inode)) < 0) break;
 382                 if (error) {
 383                         fat_truncate(inode);
 384                         break;
 385                 }
 386                 offset = *ppos & (SECTOR_SIZE-1);
 387                 size = MIN(SECTOR_SIZE-offset,MAX(carry,count));
 388                 if (binary_mode
 389                         && offset == 0
 390                         && (size == SECTOR_SIZE
 391                                 || *ppos + size >= inode->i_size)){
 392                         /* No need to read the block first since we will */
 393                         /* completely overwrite it */
 394                         /* or at least write past the end of file */
 395                         if (!(bh = fat_getblk(sb,sector))){
 396                                 error = -EIO;
 397                                 break;
 398                         }
 399                 } else if (!(bh = fat_bread(sb,sector))) {
 400                         error = -EIO;
 401                         break;
 402                 }
 403                 if (binary_mode) {
 404                         copy_from_user(bh->b_data+offset,buf,written = size);
 405                         buf += size;
 406                 } else {
 407                         written = left = SECTOR_SIZE-offset;
 408                         to = (char *) bh->b_data+(*ppos & (SECTOR_SIZE-1));
 409                         if (carry) {
 410                                 *to++ = '\n';
 411                                 left--;
 412                                 carry = 0;
 413                         }
 414                         for (size = 0; size < count && left; size++) {
 415                                 get_user(ch, buf++);
 416                                 if (ch == '\n') {
 417                                         *to++ = '\r';
 418                                         left--;
 419                                 }
 420                                 if (!left) carry = 1;
 421                                 else {
 422                                         *to++ = ch;
 423                                         left--;
 424                                 }
 425                         }
 426                         written -= left;
 427                 }
 428                 update_vm_cache(inode, *ppos, bh->b_data + (*ppos & (SECTOR_SIZE-1)), written);
 429                 *ppos += written;
 430                 if (*ppos > inode->i_size) {
 431                         inode->i_size = *ppos;
 432                         mark_inode_dirty(inode);
 433                 }
 434                 fat_set_uptodate(sb, bh, 1);
 435                 fat_mark_buffer_dirty(sb, bh, 0);
 436                 fat_brelse(sb, bh);
 437         }
 438         if (start == buf)
 439                 return error;
 440         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 441         MSDOS_I(inode)->i_attrs |= ATTR_ARCH;
 442         mark_inode_dirty(inode);
 443         return buf-start;
 444 }
 445
 446 void fat_truncate(struct inode *inode)
 447 {
 448         int cluster;
 449
 450         /* Why no return value?  Surely the disk could fail... */
 451         if (IS_IMMUTABLE(inode))
 452                 return /* -EPERM */;
 453         cluster = SECTOR_SIZE*MSDOS_SB(inode->i_sb)->cluster_size;
 454         (void) fat_free(inode,(inode->i_size+(cluster-1))/cluster);
 455         MSDOS_I(inode)->i_attrs |= ATTR_ARCH;
 456         mark_inode_dirty(inode);
 457 }