buffer.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*
    2  *  linux/fs/hpfs/buffer.c
    3  *
    4  *  Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
    5  *
    6  *  general buffer i/o
    7  */
    8 #include <linux/sched.h>
    9 #include <linux/slab.h>
   10 #include "hpfs_fn.h"
   11 
   12 /* Map a sector into a buffer and return pointers to it and to the buffer. */
   13 
   14 void *hpfs_map_sector(struct super_block *s, unsigned secno, struct buffer_head **bhp,
   15                  int ahead)
   16 {
   17         struct buffer_head *bh;
   18 
   19         hpfs_lock_assert(s);
   20 
   21         cond_resched();
   22 
   23         *bhp = bh = sb_bread(s, secno);
   24         if (bh != NULL)
   25                 return bh->b_data;
   26         else {
   27                 printk("HPFS: hpfs_map_sector: read error\n");
   28                 return NULL;
   29         }
   30 }
   31 
   32 /* Like hpfs_map_sector but don't read anything */
   33 
   34 void *hpfs_get_sector(struct super_block *s, unsigned secno, struct buffer_head **bhp)
   35 {
   36         struct buffer_head *bh;
   37         /*return hpfs_map_sector(s, secno, bhp, 0);*/
   38 
   39         hpfs_lock_assert(s);
   40 
   41         cond_resched();
   42 
   43         if ((*bhp = bh = sb_getblk(s, secno)) != NULL) {
   44                 if (!buffer_uptodate(bh)) wait_on_buffer(bh);
   45                 set_buffer_uptodate(bh);
   46                 return bh->b_data;
   47         } else {
   48                 printk("HPFS: hpfs_get_sector: getblk failed\n");
   49                 return NULL;
   50         }
   51 }
   52 
   53 /* Map 4 sectors into a 4buffer and return pointers to it and to the buffer. */
   54 
   55 void *hpfs_map_4sectors(struct super_block *s, unsigned secno, struct quad_buffer_head *qbh,
   56                    int ahead)
   57 {
   58         struct buffer_head *bh;
   59         char *data;
   60 
   61         hpfs_lock_assert(s);
   62 
   63         cond_resched();
   64 
   65         if (secno & 3) {
   66                 printk("HPFS: hpfs_map_4sectors: unaligned read\n");
   67                 return NULL;
   68         }
   69 
   70         qbh->data = data = kmalloc(2048, GFP_NOFS);
   71         if (!data) {
   72                 printk("HPFS: hpfs_map_4sectors: out of memory\n");
   73                 goto bail;
   74         }
   75 
   76         qbh->bh[0] = bh = sb_bread(s, secno);
   77         if (!bh)
   78                 goto bail0;
   79         memcpy(data, bh->b_data, 512);
   80 
   81         qbh->bh[1] = bh = sb_bread(s, secno + 1);
   82         if (!bh)
   83                 goto bail1;
   84         memcpy(data + 512, bh->b_data, 512);
   85 
   86         qbh->bh[2] = bh = sb_bread(s, secno + 2);
   87         if (!bh)
   88                 goto bail2;
   89         memcpy(data + 2 * 512, bh->b_data, 512);
   90 
   91         qbh->bh[3] = bh = sb_bread(s, secno + 3);
   92         if (!bh)
   93                 goto bail3;
   94         memcpy(data + 3 * 512, bh->b_data, 512);
   95 
   96         return data;
   97 
   98  bail3:
   99         brelse(qbh->bh[2]);
  100  bail2:
  101         brelse(qbh->bh[1]);
  102  bail1:
  103         brelse(qbh->bh[0]);
  104  bail0:
  105         kfree(data);
  106         printk("HPFS: hpfs_map_4sectors: read error\n");
  107  bail:
  108         return NULL;
  109 }
  110 
  111 /* Don't read sectors */
  112 
  113 void *hpfs_get_4sectors(struct super_block *s, unsigned secno,
  114                           struct quad_buffer_head *qbh)
  115 {
  116         cond_resched();
  117 
  118         hpfs_lock_assert(s);
  119 
  120         if (secno & 3) {
  121                 printk("HPFS: hpfs_get_4sectors: unaligned read\n");
  122                 return NULL;
  123         }
  124 
  125         /*return hpfs_map_4sectors(s, secno, qbh, 0);*/
  126         if (!(qbh->data = kmalloc(2048, GFP_NOFS))) {
  127                 printk("HPFS: hpfs_get_4sectors: out of memory\n");
  128                 return NULL;
  129         }
  130         if (!(hpfs_get_sector(s, secno, &qbh->bh[0]))) goto bail0;
  131         if (!(hpfs_get_sector(s, secno + 1, &qbh->bh[1]))) goto bail1;
  132         if (!(hpfs_get_sector(s, secno + 2, &qbh->bh[2]))) goto bail2;
  133         if (!(hpfs_get_sector(s, secno + 3, &qbh->bh[3]))) goto bail3;
  134         memcpy(qbh->data, qbh->bh[0]->b_data, 512);
  135         memcpy(qbh->data + 512, qbh->bh[1]->b_data, 512);
  136         memcpy(qbh->data + 2*512, qbh->bh[2]->b_data, 512);
  137         memcpy(qbh->data + 3*512, qbh->bh[3]->b_data, 512);
  138         return qbh->data;
  139 
  140         bail3:  brelse(qbh->bh[2]);
  141         bail2:  brelse(qbh->bh[1]);
  142         bail1:  brelse(qbh->bh[0]);
  143         bail0:
  144         return NULL;
  145 }
  146         
  147 
  148 void hpfs_brelse4(struct quad_buffer_head *qbh)
  149 {
  150         brelse(qbh->bh[3]);
  151         brelse(qbh->bh[2]);
  152         brelse(qbh->bh[1]);
  153         brelse(qbh->bh[0]);
  154         kfree(qbh->data);
  155 }       
  156 
  157 void hpfs_mark_4buffers_dirty(struct quad_buffer_head *qbh)
  158 {
  159         memcpy(qbh->bh[0]->b_data, qbh->data, 512);
  160         memcpy(qbh->bh[1]->b_data, qbh->data + 512, 512);
  161         memcpy(qbh->bh[2]->b_data, qbh->data + 2 * 512, 512);
  162         memcpy(qbh->bh[3]->b_data, qbh->data + 3 * 512, 512);
  163         mark_buffer_dirty(qbh->bh[0]);
  164         mark_buffer_dirty(qbh->bh[1]);
  165         mark_buffer_dirty(qbh->bh[2]);
  166         mark_buffer_dirty(qbh->bh[3]);
  167 }

Cache object: ba43dc888ad67bb3ed46c698b429c7d5

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/fs/hpfs/buffer.c

FreeBSD/Linux Kernel Cross Reference
sys/fs/hpfs/buffer.c