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 
    9 #include <linux/string.h>
   10 #include "hpfs_fn.h"
   11 
   12 void hpfs_lock_creation(struct super_block *s)
   13 {
   14 #ifdef DEBUG_LOCKS
   15         printk("lock creation\n");
   16 #endif
   17         while (s->s_hpfs_creation_de_lock) sleep_on(&s->s_hpfs_creation_de);
   18         s->s_hpfs_creation_de_lock = 1;
   19 }
   20 
   21 void hpfs_unlock_creation(struct super_block *s)
   22 {
   23 #ifdef DEBUG_LOCKS
   24         printk("unlock creation\n");
   25 #endif
   26         s->s_hpfs_creation_de_lock = 0;
   27         wake_up(&s->s_hpfs_creation_de);
   28 }
   29 
   30 void hpfs_lock_iget(struct super_block *s, int mode)
   31 {
   32 #ifdef DEBUG_LOCKS
   33         printk("lock iget\n");
   34 #endif
   35         while (s->s_hpfs_rd_inode) sleep_on(&s->s_hpfs_iget_q);
   36         s->s_hpfs_rd_inode = mode;
   37 }
   38 
   39 void hpfs_unlock_iget(struct super_block *s)
   40 {
   41 #ifdef DEBUG_LOCKS
   42         printk("unlock iget\n");
   43 #endif
   44         s->s_hpfs_rd_inode = 0;
   45         wake_up(&s->s_hpfs_iget_q);
   46 }
   47 
   48 void hpfs_lock_inode(struct inode *i)
   49 {
   50         if (i) down(&i->i_hpfs_sem);
   51 }
   52 
   53 void hpfs_unlock_inode(struct inode *i)
   54 {
   55         if (i) up(&i->i_hpfs_sem);
   56 }
   57 
   58 void hpfs_lock_2inodes(struct inode *i1, struct inode *i2)
   59 {
   60         if (!i1) { if (i2) down(&i2->i_hpfs_sem); return; }
   61         if (!i2) { if (i1) down(&i1->i_hpfs_sem); return; }
   62         if (i1->i_ino < i2->i_ino) {
   63                 down(&i1->i_hpfs_sem);
   64                 down(&i2->i_hpfs_sem);
   65         } else if (i1->i_ino > i2->i_ino) {
   66                 down(&i2->i_hpfs_sem);
   67                 down(&i1->i_hpfs_sem);
   68         } else down(&i1->i_hpfs_sem);
   69 }
   70 
   71 void hpfs_unlock_2inodes(struct inode *i1, struct inode *i2)
   72 {
   73         if (!i1) { if (i2) up(&i2->i_hpfs_sem); return; }
   74         if (!i2) { if (i1) up(&i1->i_hpfs_sem); return; }
   75         if (i1->i_ino < i2->i_ino) {
   76                 up(&i2->i_hpfs_sem);
   77                 up(&i1->i_hpfs_sem);
   78         } else if (i1->i_ino > i2->i_ino) {
   79                 up(&i1->i_hpfs_sem);
   80                 up(&i2->i_hpfs_sem);
   81         } else up(&i1->i_hpfs_sem);
   82 }
   83 
   84 void hpfs_lock_3inodes(struct inode *i1, struct inode *i2, struct inode *i3)
   85 {
   86         if (!i1) { hpfs_lock_2inodes(i2, i3); return; }
   87         if (!i2) { hpfs_lock_2inodes(i1, i3); return; }
   88         if (!i3) { hpfs_lock_2inodes(i1, i2); return; }
   89         if (i1->i_ino < i2->i_ino && i1->i_ino < i3->i_ino) {
   90                 down(&i1->i_hpfs_sem);
   91                 hpfs_lock_2inodes(i2, i3);
   92         } else if (i2->i_ino < i1->i_ino && i2->i_ino < i3->i_ino) {
   93                 down(&i2->i_hpfs_sem);
   94                 hpfs_lock_2inodes(i1, i3);
   95         } else if (i3->i_ino < i1->i_ino && i3->i_ino < i2->i_ino) {
   96                 down(&i3->i_hpfs_sem);
   97                 hpfs_lock_2inodes(i1, i2);
   98         } else if (i1->i_ino != i2->i_ino) hpfs_lock_2inodes(i1, i2);
   99         else hpfs_lock_2inodes(i1, i3);
  100 }
  101                 
  102 void hpfs_unlock_3inodes(struct inode *i1, struct inode *i2, struct inode *i3)
  103 {
  104         if (!i1) { hpfs_unlock_2inodes(i2, i3); return; }
  105         if (!i2) { hpfs_unlock_2inodes(i1, i3); return; }
  106         if (!i3) { hpfs_unlock_2inodes(i1, i2); return; }
  107         if (i1->i_ino < i2->i_ino && i1->i_ino < i3->i_ino) {
  108                 hpfs_unlock_2inodes(i2, i3);
  109                 up(&i1->i_hpfs_sem);
  110         } else if (i2->i_ino < i1->i_ino && i2->i_ino < i3->i_ino) {
  111                 hpfs_unlock_2inodes(i1, i3);
  112                 up(&i2->i_hpfs_sem);
  113         } else if (i3->i_ino < i1->i_ino && i3->i_ino < i2->i_ino) {
  114                 hpfs_unlock_2inodes(i1, i2);
  115                 up(&i3->i_hpfs_sem);
  116         } else if (i1->i_ino != i2->i_ino) hpfs_unlock_2inodes(i1, i2);
  117         else hpfs_unlock_2inodes(i1, i3);
  118 }
  119 
  120 /* Map a sector into a buffer and return pointers to it and to the buffer. */
  121 
  122 void *hpfs_map_sector(struct super_block *s, unsigned secno, struct buffer_head **bhp,
  123                  int ahead)
  124 {
  125         struct buffer_head *bh;
  126 
  127         *bhp = bh = sb_bread(s, secno);
  128         if (bh != NULL)
  129                 return bh->b_data;
  130         else {
  131                 printk("HPFS: hpfs_map_sector: read error\n");
  132                 return NULL;
  133         }
  134 }
  135 
  136 /* Like hpfs_map_sector but don't read anything */
  137 
  138 void *hpfs_get_sector(struct super_block *s, unsigned secno, struct buffer_head **bhp)
  139 {
  140         struct buffer_head *bh;
  141         /*return hpfs_map_sector(s, secno, bhp, 0);*/
  142 
  143         if ((*bhp = bh = sb_getblk(s, secno)) != NULL) {
  144                 if (!buffer_uptodate(bh)) wait_on_buffer(bh);
  145                 mark_buffer_uptodate(bh, 1);
  146                 return bh->b_data;
  147         } else {
  148                 printk("HPFS: hpfs_get_sector: getblk failed\n");
  149                 return NULL;
  150         }
  151 }
  152 
  153 /* Map 4 sectors into a 4buffer and return pointers to it and to the buffer. */
  154 
  155 void *hpfs_map_4sectors(struct super_block *s, unsigned secno, struct quad_buffer_head *qbh,
  156                    int ahead)
  157 {
  158         struct buffer_head *bh;
  159         char *data;
  160 
  161         if (secno & 3) {
  162                 printk("HPFS: hpfs_map_4sectors: unaligned read\n");
  163                 return 0;
  164         }
  165 
  166         qbh->data = data = (char *)kmalloc(2048, GFP_KERNEL);
  167         if (!data) {
  168                 printk("HPFS: hpfs_map_4sectors: out of memory\n");
  169                 goto bail;
  170         }
  171 
  172         qbh->bh[0] = bh = sb_bread(s, secno);
  173         if (!bh)
  174                 goto bail0;
  175         memcpy(data, bh->b_data, 512);
  176 
  177         qbh->bh[1] = bh = sb_bread(s, secno + 1);
  178         if (!bh)
  179                 goto bail1;
  180         memcpy(data + 512, bh->b_data, 512);
  181 
  182         qbh->bh[2] = bh = sb_bread(s, secno + 2);
  183         if (!bh)
  184                 goto bail2;
  185         memcpy(data + 2 * 512, bh->b_data, 512);
  186 
  187         qbh->bh[3] = bh = sb_bread(s, secno + 3);
  188         if (!bh)
  189                 goto bail3;
  190         memcpy(data + 3 * 512, bh->b_data, 512);
  191 
  192         return data;
  193 
  194  bail3:
  195         brelse(qbh->bh[2]);
  196  bail2:
  197         brelse(qbh->bh[1]);
  198  bail1:
  199         brelse(qbh->bh[0]);
  200  bail0:
  201         kfree(data);
  202         printk("HPFS: hpfs_map_4sectors: read error\n");
  203  bail:
  204         return NULL;
  205 }
  206 
  207 /* Don't read sectors */
  208 
  209 void *hpfs_get_4sectors(struct super_block *s, unsigned secno,
  210                           struct quad_buffer_head *qbh)
  211 {
  212         if (secno & 3) {
  213                 printk("HPFS: hpfs_get_4sectors: unaligned read\n");
  214                 return 0;
  215         }
  216 
  217         /*return hpfs_map_4sectors(s, secno, qbh, 0);*/
  218         if (!(qbh->data = kmalloc(2048, GFP_KERNEL))) {
  219                 printk("HPFS: hpfs_get_4sectors: out of memory\n");
  220                 return NULL;
  221         }
  222         if (!(hpfs_get_sector(s, secno, &qbh->bh[0]))) goto bail0;
  223         if (!(hpfs_get_sector(s, secno + 1, &qbh->bh[1]))) goto bail1;
  224         if (!(hpfs_get_sector(s, secno + 2, &qbh->bh[2]))) goto bail2;
  225         if (!(hpfs_get_sector(s, secno + 3, &qbh->bh[3]))) goto bail3;
  226         memcpy(qbh->data, qbh->bh[0]->b_data, 512);
  227         memcpy(qbh->data + 512, qbh->bh[1]->b_data, 512);
  228         memcpy(qbh->data + 2*512, qbh->bh[2]->b_data, 512);
  229         memcpy(qbh->data + 3*512, qbh->bh[3]->b_data, 512);
  230         return qbh->data;
  231 
  232         bail3:  brelse(qbh->bh[2]);
  233         bail2:  brelse(qbh->bh[1]);
  234         bail1:  brelse(qbh->bh[0]);
  235         bail0:
  236         return NULL;
  237 }
  238         
  239 
  240 void hpfs_brelse4(struct quad_buffer_head *qbh)
  241 {
  242         brelse(qbh->bh[3]);
  243         brelse(qbh->bh[2]);
  244         brelse(qbh->bh[1]);
  245         brelse(qbh->bh[0]);
  246         kfree(qbh->data);
  247 }       
  248 
  249 void hpfs_mark_4buffers_dirty(struct quad_buffer_head *qbh)
  250 {
  251         PRINTK(("hpfs_mark_4buffers_dirty\n"));
  252         memcpy(qbh->bh[0]->b_data, qbh->data, 512);
  253         memcpy(qbh->bh[1]->b_data, qbh->data + 512, 512);
  254         memcpy(qbh->bh[2]->b_data, qbh->data + 2 * 512, 512);
  255         memcpy(qbh->bh[3]->b_data, qbh->data + 3 * 512, 512);
  256         mark_buffer_dirty(qbh->bh[0]);
  257         mark_buffer_dirty(qbh->bh[1]);
  258         mark_buffer_dirty(qbh->bh[2]);
  259         mark_buffer_dirty(qbh->bh[3]);
  260 }

Cache object: 56f0badf790ce59909f3ac6bfaf2fa4c

[ 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