util.h

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/ufs/util.h
    3  *
    4  * Copyright (C) 1998 
    5  * Daniel Pirkl <daniel.pirkl@email.cz>
    6  * Charles University, Faculty of Mathematics and Physics
    7  */
    8 
    9 #include <linux/fs.h>
   10 #include "swab.h"
   11 
   12 
   13 /*
   14  * some useful macros
   15  */
   16 #define in_range(b,first,len)   ((b)>=(first)&&(b)<(first)+(len))
   17 
   18 /*
   19  * macros used for retyping
   20  */
   21 #define UCPI_UBH ((struct ufs_buffer_head *)ucpi)
   22 #define USPI_UBH ((struct ufs_buffer_head *)uspi)
   23 
   24 
   25 
   26 /*
   27  * macros used for accesing structures
   28  */
   29 static inline s32
   30 ufs_get_fs_state(struct super_block *sb, struct ufs_super_block_first *usb1,
   31                  struct ufs_super_block_third *usb3)
   32 {
   33         switch (sb->u.ufs_sb.s_flags & UFS_ST_MASK) {
   34         case UFS_ST_SUN:
   35                 return fs32_to_cpu(sb, usb3->fs_u2.fs_sun.fs_state);
   36         case UFS_ST_SUNx86:
   37                 return fs32_to_cpu(sb, usb1->fs_u1.fs_sunx86.fs_state);
   38         case UFS_ST_44BSD:
   39         default:
   40                 return fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_state);
   41         }
   42 }
   43 
   44 static inline void
   45 ufs_set_fs_state(struct super_block *sb, struct ufs_super_block_first *usb1,
   46                  struct ufs_super_block_third *usb3, s32 value)
   47 {
   48         switch (sb->u.ufs_sb.s_flags & UFS_ST_MASK) {
   49         case UFS_ST_SUN:
   50                 usb3->fs_u2.fs_sun.fs_state = cpu_to_fs32(sb, value);
   51                 break;
   52         case UFS_ST_SUNx86:
   53                 usb1->fs_u1.fs_sunx86.fs_state = cpu_to_fs32(sb, value);
   54                 break;
   55         case UFS_ST_44BSD:
   56                 usb3->fs_u2.fs_44.fs_state = cpu_to_fs32(sb, value);
   57                 break;
   58         }
   59 }
   60 
   61 static inline u32
   62 ufs_get_fs_npsect(struct super_block *sb, struct ufs_super_block_first *usb1,
   63                   struct ufs_super_block_third *usb3)
   64 {
   65         if ((sb->u.ufs_sb.s_flags & UFS_ST_MASK) == UFS_ST_SUNx86)
   66                 return fs32_to_cpu(sb, usb3->fs_u2.fs_sunx86.fs_npsect);
   67         else
   68                 return fs32_to_cpu(sb, usb1->fs_u1.fs_sun.fs_npsect);
   69 }
   70 
   71 static inline u64
   72 ufs_get_fs_qbmask(struct super_block *sb, struct ufs_super_block_third *usb3)
   73 {
   74         u64 tmp;
   75 
   76         switch (sb->u.ufs_sb.s_flags & UFS_ST_MASK) {
   77         case UFS_ST_SUN:
   78                 ((u32 *)&tmp)[0] = usb3->fs_u2.fs_sun.fs_qbmask[0];
   79                 ((u32 *)&tmp)[1] = usb3->fs_u2.fs_sun.fs_qbmask[1];
   80                 break;
   81         case UFS_ST_SUNx86:
   82                 ((u32 *)&tmp)[0] = usb3->fs_u2.fs_sunx86.fs_qbmask[0];
   83                 ((u32 *)&tmp)[1] = usb3->fs_u2.fs_sunx86.fs_qbmask[1];
   84                 break;
   85         case UFS_ST_44BSD:
   86                 ((u32 *)&tmp)[0] = usb3->fs_u2.fs_44.fs_qbmask[0];
   87                 ((u32 *)&tmp)[1] = usb3->fs_u2.fs_44.fs_qbmask[1];
   88                 break;
   89         }
   90 
   91         return fs64_to_cpu(sb, tmp);
   92 }
   93 
   94 static inline u64
   95 ufs_get_fs_qfmask(struct super_block *sb, struct ufs_super_block_third *usb3)
   96 {
   97         u64 tmp;
   98 
   99         switch (sb->u.ufs_sb.s_flags & UFS_ST_MASK) {
  100         case UFS_ST_SUN:
  101                 ((u32 *)&tmp)[0] = usb3->fs_u2.fs_sun.fs_qfmask[0];
  102                 ((u32 *)&tmp)[1] = usb3->fs_u2.fs_sun.fs_qfmask[1];
  103                 break;
  104         case UFS_ST_SUNx86:
  105                 ((u32 *)&tmp)[0] = usb3->fs_u2.fs_sunx86.fs_qfmask[0];
  106                 ((u32 *)&tmp)[1] = usb3->fs_u2.fs_sunx86.fs_qfmask[1];
  107                 break;
  108         case UFS_ST_44BSD:
  109                 ((u32 *)&tmp)[0] = usb3->fs_u2.fs_44.fs_qfmask[0];
  110                 ((u32 *)&tmp)[1] = usb3->fs_u2.fs_44.fs_qfmask[1];
  111                 break;
  112         }
  113 
  114         return fs64_to_cpu(sb, tmp);
  115 }
  116 
  117 static inline u16
  118 ufs_get_de_namlen(struct super_block *sb, struct ufs_dir_entry *de)
  119 {
  120         if ((sb->u.ufs_sb.s_flags & UFS_DE_MASK) == UFS_DE_OLD)
  121                 return fs16_to_cpu(sb, de->d_u.d_namlen);
  122         else
  123                 return de->d_u.d_44.d_namlen; /* XXX this seems wrong */
  124 }
  125 
  126 static inline void
  127 ufs_set_de_namlen(struct super_block *sb, struct ufs_dir_entry *de, u16 value)
  128 {
  129         if ((sb->u.ufs_sb.s_flags & UFS_DE_MASK) == UFS_DE_OLD)
  130                 de->d_u.d_namlen = cpu_to_fs16(sb, value);
  131         else
  132                 de->d_u.d_44.d_namlen = value; /* XXX this seems wrong */
  133 }
  134 
  135 static inline void
  136 ufs_set_de_type(struct super_block *sb, struct ufs_dir_entry *de, int mode)
  137 {
  138         if ((sb->u.ufs_sb.s_flags & UFS_DE_MASK) != UFS_DE_44BSD)
  139                 return;
  140 
  141         /*
  142          * TODO turn this into a table lookup
  143          */
  144         switch (mode & S_IFMT) {
  145         case S_IFSOCK:
  146                 de->d_u.d_44.d_type = DT_SOCK;
  147                 break;
  148         case S_IFLNK:
  149                 de->d_u.d_44.d_type = DT_LNK;
  150                 break;
  151         case S_IFREG:
  152                 de->d_u.d_44.d_type = DT_REG;
  153                 break;
  154         case S_IFBLK:
  155                 de->d_u.d_44.d_type = DT_BLK;
  156                 break;
  157         case S_IFDIR:
  158                 de->d_u.d_44.d_type = DT_DIR;
  159                 break;
  160         case S_IFCHR:
  161                 de->d_u.d_44.d_type = DT_CHR;
  162                 break;
  163         case S_IFIFO:
  164                 de->d_u.d_44.d_type = DT_FIFO;
  165                 break;
  166         default:
  167                 de->d_u.d_44.d_type = DT_UNKNOWN;
  168         }
  169 }
  170 
  171 static inline u32
  172 ufs_get_inode_uid(struct super_block *sb, struct ufs_inode *inode)
  173 {
  174         switch (sb->u.ufs_sb.s_flags & UFS_UID_MASK) {
  175         case UFS_UID_EFT:
  176                 return fs32_to_cpu(sb, inode->ui_u3.ui_sun.ui_uid);
  177         case UFS_UID_44BSD:
  178                 return fs32_to_cpu(sb, inode->ui_u3.ui_44.ui_uid);
  179         default:
  180                 return fs16_to_cpu(sb, inode->ui_u1.oldids.ui_suid);
  181         }
  182 }
  183 
  184 static inline void
  185 ufs_set_inode_uid(struct super_block *sb, struct ufs_inode *inode, u32 value)
  186 {
  187         switch (sb->u.ufs_sb.s_flags & UFS_UID_MASK) {
  188         case UFS_UID_EFT:
  189                 inode->ui_u3.ui_sun.ui_uid = cpu_to_fs32(sb, value);
  190                 break;
  191         case UFS_UID_44BSD:
  192                 inode->ui_u3.ui_44.ui_uid = cpu_to_fs32(sb, value);
  193                 break;
  194         }
  195         inode->ui_u1.oldids.ui_suid = cpu_to_fs16(sb, value); 
  196 }
  197 
  198 static inline u32
  199 ufs_get_inode_gid(struct super_block *sb, struct ufs_inode *inode)
  200 {
  201         switch (sb->u.ufs_sb.s_flags & UFS_UID_MASK) {
  202         case UFS_UID_EFT:
  203                 return fs32_to_cpu(sb, inode->ui_u3.ui_sun.ui_gid);
  204         case UFS_UID_44BSD:
  205                 return fs32_to_cpu(sb, inode->ui_u3.ui_44.ui_gid);
  206         default:
  207                 return fs16_to_cpu(sb, inode->ui_u1.oldids.ui_sgid);
  208         }
  209 }
  210 
  211 static inline void
  212 ufs_set_inode_gid(struct super_block *sb, struct ufs_inode *inode, u32 value)
  213 {
  214         switch (sb->u.ufs_sb.s_flags & UFS_UID_MASK) {
  215         case UFS_UID_EFT:
  216                 inode->ui_u3.ui_sun.ui_gid = cpu_to_fs32(sb, value);
  217                 break;
  218         case UFS_UID_44BSD:
  219                 inode->ui_u3.ui_44.ui_gid = cpu_to_fs32(sb, value);
  220                 break;
  221         }
  222         inode->ui_u1.oldids.ui_sgid =  cpu_to_fs16(sb, value);
  223 }
  224 
  225 
  226 /*
  227  * These functions manipulate ufs buffers
  228  */
  229 #define ubh_bread(sb,fragment,size) _ubh_bread_(uspi,sb,fragment,size)  
  230 extern struct ufs_buffer_head * _ubh_bread_(struct ufs_sb_private_info *, struct super_block *, unsigned, unsigned);
  231 extern struct ufs_buffer_head * ubh_bread_uspi(struct ufs_sb_private_info *, struct super_block *, unsigned, unsigned);
  232 extern void ubh_brelse (struct ufs_buffer_head *);
  233 extern void ubh_brelse_uspi (struct ufs_sb_private_info *);
  234 extern void ubh_mark_buffer_dirty (struct ufs_buffer_head *);
  235 extern void ubh_mark_buffer_uptodate (struct ufs_buffer_head *, int);
  236 extern void ubh_ll_rw_block (int, unsigned, struct ufs_buffer_head **);
  237 extern void ubh_wait_on_buffer (struct ufs_buffer_head *);
  238 extern unsigned ubh_max_bcount (struct ufs_buffer_head *);
  239 extern void ubh_bforget (struct ufs_buffer_head *);
  240 extern int  ubh_buffer_dirty (struct ufs_buffer_head *);
  241 #define ubh_ubhcpymem(mem,ubh,size) _ubh_ubhcpymem_(uspi,mem,ubh,size)
  242 extern void _ubh_ubhcpymem_(struct ufs_sb_private_info *, unsigned char *, struct ufs_buffer_head *, unsigned);
  243 #define ubh_memcpyubh(ubh,mem,size) _ubh_memcpyubh_(uspi,ubh,mem,size)
  244 extern void _ubh_memcpyubh_(struct ufs_sb_private_info *, struct ufs_buffer_head *, unsigned char *, unsigned);
  245 
  246 
  247 
  248 /*
  249  * macros to get important structures from ufs_buffer_head
  250  */
  251 #define ubh_get_usb_first(ubh) \
  252         ((struct ufs_super_block_first *)((ubh)->bh[0]->b_data))
  253 
  254 #define ubh_get_usb_second(ubh) \
  255         ((struct ufs_super_block_second *)(ubh)-> \
  256         bh[UFS_SECTOR_SIZE >> uspi->s_fshift]->b_data + (UFS_SECTOR_SIZE & ~uspi->s_fmask))
  257 
  258 #define ubh_get_usb_third(ubh) \
  259         ((struct ufs_super_block_third *)((ubh)-> \
  260         bh[UFS_SECTOR_SIZE*2 >> uspi->s_fshift]->b_data + (UFS_SECTOR_SIZE*2 & ~uspi->s_fmask)))
  261 
  262 #define ubh_get_ucg(ubh) \
  263         ((struct ufs_cylinder_group *)((ubh)->bh[0]->b_data))
  264 
  265 
  266 /*
  267  * Extract byte from ufs_buffer_head
  268  * Extract the bits for a block from a map inside ufs_buffer_head
  269  */
  270 #define ubh_get_addr8(ubh,begin) \
  271         ((u8*)(ubh)->bh[(begin) >> uspi->s_fshift]->b_data + \
  272         ((begin) & ~uspi->s_fmask))
  273 
  274 #define ubh_get_addr16(ubh,begin) \
  275         (((u16*)((ubh)->bh[(begin) >> (uspi->s_fshift-1)]->b_data)) + \
  276         ((begin) & (uspi->fsize>>1) - 1)))
  277 
  278 #define ubh_get_addr32(ubh,begin) \
  279         (((u32*)((ubh)->bh[(begin) >> (uspi->s_fshift-2)]->b_data)) + \
  280         ((begin) & ((uspi->s_fsize>>2) - 1)))
  281 
  282 #define ubh_get_addr ubh_get_addr8
  283 
  284 #define ubh_blkmap(ubh,begin,bit) \
  285         ((*ubh_get_addr(ubh, (begin) + ((bit) >> 3)) >> ((bit) & 7)) & (0xff >> (UFS_MAXFRAG - uspi->s_fpb)))
  286 
  287 
  288 /*
  289  * Macros for access to superblock array structures
  290  */
  291 #define ubh_postbl(ubh,cylno,i) \
  292         ((uspi->s_postblformat != UFS_DYNAMICPOSTBLFMT) \
  293         ? (*(__s16*)(ubh_get_addr(ubh, \
  294         (unsigned)(&((struct ufs_super_block *)0)->fs_opostbl) \
  295         + (((cylno) * 16 + (i)) << 1) ) )) \
  296         : (*(__s16*)(ubh_get_addr(ubh, \
  297         uspi->s_postbloff + (((cylno) * uspi->s_nrpos + (i)) << 1) ))))
  298 
  299 #define ubh_rotbl(ubh,i) \
  300         ((uspi->s_postblformat != UFS_DYNAMICPOSTBLFMT) \
  301         ? (*(__u8*)(ubh_get_addr(ubh, \
  302         (unsigned)(&((struct ufs_super_block *)0)->fs_space) + (i)))) \
  303         : (*(__u8*)(ubh_get_addr(ubh, uspi->s_rotbloff + (i)))))
  304 
  305 /*
  306  * Determine the number of available frags given a
  307  * percentage to hold in reserve.
  308  */
  309 #define ufs_freespace(usb, percentreserved) \
  310         (ufs_blkstofrags(fs32_to_cpu(sb, (usb)->fs_cstotal.cs_nbfree)) + \
  311         fs32_to_cpu(sb, (usb)->fs_cstotal.cs_nffree) - (uspi->s_dsize * (percentreserved) / 100))
  312 
  313 /*
  314  * Macros to access cylinder group array structures
  315  */
  316 #define ubh_cg_blktot(ucpi,cylno) \
  317         (*((__u32*)ubh_get_addr(UCPI_UBH, (ucpi)->c_btotoff + ((cylno) << 2))))
  318 
  319 #define ubh_cg_blks(ucpi,cylno,rpos) \
  320         (*((__u16*)ubh_get_addr(UCPI_UBH, \
  321         (ucpi)->c_boff + (((cylno) * uspi->s_nrpos + (rpos)) << 1 ))))
  322 
  323 /*
  324  * Bitmap operations
  325  * These functions work like classical bitmap operations.
  326  * The difference is that we don't have the whole bitmap
  327  * in one contiguous chunk of memory, but in several buffers.
  328  * The parameters of each function are super_block, ufs_buffer_head and
  329  * position of the beginning of the bitmap.
  330  */
  331 #define ubh_setbit(ubh,begin,bit) \
  332         (*ubh_get_addr(ubh, (begin) + ((bit) >> 3)) |= (1 << ((bit) & 7)))
  333 
  334 #define ubh_clrbit(ubh,begin,bit) \
  335         (*ubh_get_addr (ubh, (begin) + ((bit) >> 3)) &= ~(1 << ((bit) & 7)))
  336 
  337 #define ubh_isset(ubh,begin,bit) \
  338         (*ubh_get_addr (ubh, (begin) + ((bit) >> 3)) & (1 << ((bit) & 7)))
  339 
  340 #define ubh_isclr(ubh,begin,bit) (!ubh_isset(ubh,begin,bit))
  341 
  342 #define ubh_find_first_zero_bit(ubh,begin,size) _ubh_find_next_zero_bit_(uspi,ubh,begin,size,0)
  343 
  344 #define ubh_find_next_zero_bit(ubh,begin,size,offset) _ubh_find_next_zero_bit_(uspi,ubh,begin,size,offset)
  345 static inline unsigned _ubh_find_next_zero_bit_(
  346         struct ufs_sb_private_info * uspi, struct ufs_buffer_head * ubh,
  347         unsigned begin, unsigned size, unsigned offset)
  348 {
  349         unsigned base, count, pos;
  350 
  351         size -= offset;
  352         begin <<= 3;
  353         offset += begin;
  354         base = offset >> uspi->s_bpfshift;
  355         offset &= uspi->s_bpfmask;
  356         for (;;) {
  357                 count = min_t(unsigned int, size + offset, uspi->s_bpf);
  358                 size -= count - offset;
  359                 pos = ext2_find_next_zero_bit (ubh->bh[base]->b_data, count, offset);
  360                 if (pos < count || !size)
  361                         break;
  362                 base++;
  363                 offset = 0;
  364         }
  365         return (base << uspi->s_bpfshift) + pos - begin;
  366 }       
  367 
  368 static inline unsigned find_last_zero_bit (unsigned char * bitmap,
  369         unsigned size, unsigned offset)
  370 {
  371         unsigned bit, i;
  372         unsigned char * mapp;
  373         unsigned char map;
  374 
  375         mapp = bitmap + (size >> 3);
  376         map = *mapp--;
  377         bit = 1 << (size & 7);
  378         for (i = size; i > offset; i--) {
  379                 if ((map & bit) == 0)
  380                         break;
  381                 if ((i & 7) != 0) {
  382                         bit >>= 1;
  383                 } else {
  384                         map = *mapp--;
  385                         bit = 1 << 7;
  386                 }
  387         }
  388         return i;
  389 }
  390 
  391 #define ubh_find_last_zero_bit(ubh,begin,size,offset) _ubh_find_last_zero_bit_(uspi,ubh,begin,size,offset)
  392 static inline unsigned _ubh_find_last_zero_bit_(
  393         struct ufs_sb_private_info * uspi, struct ufs_buffer_head * ubh,
  394         unsigned begin, unsigned start, unsigned end)
  395 {
  396         unsigned base, count, pos, size;
  397 
  398         size = start - end;
  399         begin <<= 3;
  400         start += begin;
  401         base = start >> uspi->s_bpfshift;
  402         start &= uspi->s_bpfmask;
  403         for (;;) {
  404                 count = min_t(unsigned int,
  405                             size + (uspi->s_bpf - start), uspi->s_bpf)
  406                         - (uspi->s_bpf - start);
  407                 size -= count;
  408                 pos = find_last_zero_bit (ubh->bh[base]->b_data,
  409                         start, start - count);
  410                 if (pos > start - count || !size)
  411                         break;
  412                 base--;
  413                 start = uspi->s_bpf;
  414         }
  415         return (base << uspi->s_bpfshift) + pos - begin;
  416 }       
  417 
  418 #define ubh_isblockclear(ubh,begin,block) (!_ubh_isblockset_(uspi,ubh,begin,block))
  419 
  420 #define ubh_isblockset(ubh,begin,block) _ubh_isblockset_(uspi,ubh,begin,block)
  421 static inline int _ubh_isblockset_(struct ufs_sb_private_info * uspi,
  422         struct ufs_buffer_head * ubh, unsigned begin, unsigned block)
  423 {
  424         switch (uspi->s_fpb) {
  425         case 8:
  426                 return (*ubh_get_addr (ubh, begin + block) == 0xff);
  427         case 4:
  428                 return (*ubh_get_addr (ubh, begin + (block >> 1)) == (0x0f << ((block & 0x01) << 2)));
  429         case 2:
  430                 return (*ubh_get_addr (ubh, begin + (block >> 2)) == (0x03 << ((block & 0x03) << 1)));
  431         case 1:
  432                 return (*ubh_get_addr (ubh, begin + (block >> 3)) == (0x01 << (block & 0x07)));
  433         }
  434         return 0;       
  435 }
  436 
  437 #define ubh_clrblock(ubh,begin,block) _ubh_clrblock_(uspi,ubh,begin,block)
  438 static inline void _ubh_clrblock_(struct ufs_sb_private_info * uspi,
  439         struct ufs_buffer_head * ubh, unsigned begin, unsigned block)
  440 {
  441         switch (uspi->s_fpb) {
  442         case 8:
  443                 *ubh_get_addr (ubh, begin + block) = 0x00;
  444                 return; 
  445         case 4:
  446                 *ubh_get_addr (ubh, begin + (block >> 1)) &= ~(0x0f << ((block & 0x01) << 2));
  447                 return;
  448         case 2:
  449                 *ubh_get_addr (ubh, begin + (block >> 2)) &= ~(0x03 << ((block & 0x03) << 1));
  450                 return;
  451         case 1:
  452                 *ubh_get_addr (ubh, begin + (block >> 3)) &= ~(0x01 << ((block & 0x07)));
  453                 return;
  454         }
  455 }
  456 
  457 #define ubh_setblock(ubh,begin,block) _ubh_setblock_(uspi,ubh,begin,block)
  458 static inline void _ubh_setblock_(struct ufs_sb_private_info * uspi,
  459         struct ufs_buffer_head * ubh, unsigned begin, unsigned block)
  460 {
  461         switch (uspi->s_fpb) {
  462         case 8:
  463                 *ubh_get_addr(ubh, begin + block) = 0xff;
  464                 return;
  465         case 4:
  466                 *ubh_get_addr(ubh, begin + (block >> 1)) |= (0x0f << ((block & 0x01) << 2));
  467                 return;
  468         case 2:
  469                 *ubh_get_addr(ubh, begin + (block >> 2)) |= (0x03 << ((block & 0x03) << 1));
  470                 return;
  471         case 1:
  472                 *ubh_get_addr(ubh, begin + (block >> 3)) |= (0x01 << ((block & 0x07)));
  473                 return;
  474         }
  475 }
  476 
  477 static inline void ufs_fragacct (struct super_block * sb, unsigned blockmap,
  478         unsigned * fraglist, int cnt)
  479 {
  480         struct ufs_sb_private_info * uspi;
  481         unsigned fragsize, pos;
  482         
  483         uspi = sb->u.ufs_sb.s_uspi;
  484         
  485         fragsize = 0;
  486         for (pos = 0; pos < uspi->s_fpb; pos++) {
  487                 if (blockmap & (1 << pos)) {
  488                         fragsize++;
  489                 }
  490                 else if (fragsize > 0) {
  491                         fs32_add(sb, &fraglist[fragsize], cnt);
  492                         fragsize = 0;
  493                 }
  494         }
  495         if (fragsize > 0 && fragsize < uspi->s_fpb)
  496                 fs32_add(sb, &fraglist[fragsize], cnt);
  497 }
  498 
  499 #define ubh_scanc(ubh,begin,size,table,mask) _ubh_scanc_(uspi,ubh,begin,size,table,mask)
  500 static inline unsigned _ubh_scanc_(struct ufs_sb_private_info * uspi, struct ufs_buffer_head * ubh, 
  501         unsigned begin, unsigned size, unsigned char * table, unsigned char mask)
  502 {
  503         unsigned rest, offset;
  504         unsigned char * cp;
  505         
  506 
  507         offset = begin & ~uspi->s_fmask;
  508         begin >>= uspi->s_fshift;
  509         for (;;) {
  510                 if ((offset + size) < uspi->s_fsize)
  511                         rest = size;
  512                 else
  513                         rest = uspi->s_fsize - offset;
  514                 size -= rest;
  515                 cp = ubh->bh[begin]->b_data + offset;
  516                 while ((table[*cp++] & mask) == 0 && --rest);
  517                 if (rest || !size)
  518                         break;
  519                 begin++;
  520                 offset = 0;
  521         }
  522         return (size + rest);
  523 }
Cache object: 95eba4714c2d7a4acebf652125b86f6b
[ 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/ufs/util.h

FreeBSD/Linux Kernel Cross Reference
sys/fs/ufs/util.h
