1/* 2 * linux/fs/ufs/util.c 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/string.h> 10#include <linux/slab.h> 11#include <linux/ufs_fs.h> 12#include <linux/buffer_head.h> 13 14#include "swab.h" 15#include "util.h" 16 17struct ufs_buffer_head * _ubh_bread_ (struct ufs_sb_private_info * uspi, 18 struct super_block *sb, u64 fragment, u64 size) 19{ 20 struct ufs_buffer_head * ubh; 21 unsigned i, j ; 22 u64 count = 0; 23 if (size & ~uspi->s_fmask) 24 return NULL; 25 count = size >> uspi->s_fshift; 26 if (count > UFS_MAXFRAG) 27 return NULL; 28 ubh = (struct ufs_buffer_head *) 29 kmalloc (sizeof (struct ufs_buffer_head), GFP_KERNEL); 30 if (!ubh) 31 return NULL; 32 ubh->fragment = fragment; 33 ubh->count = count; 34 for (i = 0; i < count; i++) 35 if (!(ubh->bh[i] = sb_bread(sb, fragment + i))) 36 goto failed; 37 for (; i < UFS_MAXFRAG; i++) 38 ubh->bh[i] = NULL; 39 return ubh; 40failed: 41 for (j = 0; j < i; j++) 42 brelse (ubh->bh[j]); 43 kfree(ubh); 44 return NULL; 45} 46 47struct ufs_buffer_head * ubh_bread_uspi (struct ufs_sb_private_info * uspi, 48 struct super_block *sb, u64 fragment, u64 size) 49{ 50 unsigned i, j; 51 u64 count = 0; 52 if (size & ~uspi->s_fmask) 53 return NULL; 54 count = size >> uspi->s_fshift; 55 if (count <= 0 || count > UFS_MAXFRAG) 56 return NULL; 57 USPI_UBH(uspi)->fragment = fragment; 58 USPI_UBH(uspi)->count = count; 59 for (i = 0; i < count; i++) 60 if (!(USPI_UBH(uspi)->bh[i] = sb_bread(sb, fragment + i))) 61 goto failed; 62 for (; i < UFS_MAXFRAG; i++) 63 USPI_UBH(uspi)->bh[i] = NULL; 64 return USPI_UBH(uspi); 65failed: 66 for (j = 0; j < i; j++) 67 brelse (USPI_UBH(uspi)->bh[j]); 68 return NULL; 69} 70 71void ubh_brelse (struct ufs_buffer_head * ubh) 72{ 73 unsigned i; 74 if (!ubh) 75 return; 76 for (i = 0; i < ubh->count; i++) 77 brelse (ubh->bh[i]); 78 kfree (ubh); 79} 80 81void ubh_brelse_uspi (struct ufs_sb_private_info * uspi) 82{ 83 unsigned i; 84 if (!USPI_UBH(uspi)) 85 return; 86 for ( i = 0; i < USPI_UBH(uspi)->count; i++ ) { 87 brelse (USPI_UBH(uspi)->bh[i]); 88 USPI_UBH(uspi)->bh[i] = NULL; 89 } 90} 91 92void ubh_mark_buffer_dirty (struct ufs_buffer_head * ubh) 93{ 94 unsigned i; 95 if (!ubh) 96 return; 97 for ( i = 0; i < ubh->count; i++ ) 98 mark_buffer_dirty (ubh->bh[i]); 99} 100 101void ubh_mark_buffer_uptodate (struct ufs_buffer_head * ubh, int flag) 102{ 103 unsigned i; 104 if (!ubh) 105 return; 106 if (flag) { 107 for ( i = 0; i < ubh->count; i++ ) 108 set_buffer_uptodate (ubh->bh[i]); 109 } else { 110 for ( i = 0; i < ubh->count; i++ ) 111 clear_buffer_uptodate (ubh->bh[i]); 112 } 113} 114 115void ubh_ll_rw_block(int rw, struct ufs_buffer_head *ubh) 116{ 117 if (!ubh) 118 return; 119 120 ll_rw_block(rw, ubh->count, ubh->bh); 121} 122 123void ubh_wait_on_buffer (struct ufs_buffer_head * ubh) 124{ 125 unsigned i; 126 if (!ubh) 127 return; 128 for ( i = 0; i < ubh->count; i++ ) 129 wait_on_buffer (ubh->bh[i]); 130} 131 132void ubh_bforget (struct ufs_buffer_head * ubh) 133{ 134 unsigned i; 135 if (!ubh) 136 return; 137 for ( i = 0; i < ubh->count; i++ ) if ( ubh->bh[i] ) 138 bforget (ubh->bh[i]); 139} 140 141int ubh_buffer_dirty (struct ufs_buffer_head * ubh) 142{ 143 unsigned i; 144 unsigned result = 0; 145 if (!ubh) 146 return 0; 147 for ( i = 0; i < ubh->count; i++ ) 148 result |= buffer_dirty(ubh->bh[i]); 149 return result; 150} 151 152void _ubh_ubhcpymem_(struct ufs_sb_private_info * uspi, 153 unsigned char * mem, struct ufs_buffer_head * ubh, unsigned size) 154{ 155 unsigned len, bhno; 156 if (size > (ubh->count << uspi->s_fshift)) 157 size = ubh->count << uspi->s_fshift; 158 bhno = 0; 159 while (size) { 160 len = min_t(unsigned int, size, uspi->s_fsize); 161 memcpy (mem, ubh->bh[bhno]->b_data, len); 162 mem += uspi->s_fsize; 163 size -= len; 164 bhno++; 165 } 166} 167 168void _ubh_memcpyubh_(struct ufs_sb_private_info * uspi, 169 struct ufs_buffer_head * ubh, unsigned char * mem, unsigned size) 170{ 171 unsigned len, bhno; 172 if (size > (ubh->count << uspi->s_fshift)) 173 size = ubh->count << uspi->s_fshift; 174 bhno = 0; 175 while (size) { 176 len = min_t(unsigned int, size, uspi->s_fsize); 177 memcpy (ubh->bh[bhno]->b_data, mem, len); 178 mem += uspi->s_fsize; 179 size -= len; 180 bhno++; 181 } 182} 183 184dev_t 185ufs_get_inode_dev(struct super_block *sb, struct ufs_inode_info *ufsi) 186{ 187 __u32 fs32; 188 dev_t dev; 189 190 if ((UFS_SB(sb)->s_flags & UFS_ST_MASK) == UFS_ST_SUNx86) 191 fs32 = fs32_to_cpu(sb, ufsi->i_u1.i_data[1]); 192 else 193 fs32 = fs32_to_cpu(sb, ufsi->i_u1.i_data[0]); 194 switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) { 195 case UFS_ST_SUNx86: 196 case UFS_ST_SUN: 197 if ((fs32 & 0xffff0000) == 0 || 198 (fs32 & 0xffff0000) == 0xffff0000) 199 dev = old_decode_dev(fs32 & 0x7fff); 200 else 201 dev = MKDEV(sysv_major(fs32), sysv_minor(fs32)); 202 break; 203 204 default: 205 dev = old_decode_dev(fs32); 206 break; 207 } 208 return dev; 209} 210 211void 212ufs_set_inode_dev(struct super_block *sb, struct ufs_inode_info *ufsi, dev_t dev) 213{ 214 __u32 fs32; 215 216 switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) { 217 case UFS_ST_SUNx86: 218 case UFS_ST_SUN: 219 fs32 = sysv_encode_dev(dev); 220 if ((fs32 & 0xffff8000) == 0) { 221 fs32 = old_encode_dev(dev); 222 } 223 break; 224 225 default: 226 fs32 = old_encode_dev(dev); 227 break; 228 } 229 if ((UFS_SB(sb)->s_flags & UFS_ST_MASK) == UFS_ST_SUNx86) 230 ufsi->i_u1.i_data[1] = cpu_to_fs32(sb, fs32); 231 else 232 ufsi->i_u1.i_data[0] = cpu_to_fs32(sb, fs32); 233} 234 235/** 236 * ufs_get_locked_page() - locate, pin and lock a pagecache page, if not exist 237 * read it from disk. 238 * @mapping: the address_space to search 239 * @index: the page index 240 * 241 * Locates the desired pagecache page, if not exist we'll read it, 242 * locks it, increments its reference 243 * count and returns its address. 244 * 245 */ 246 247struct page *ufs_get_locked_page(struct address_space *mapping, 248 pgoff_t index) 249{ 250 struct page *page; 251 252 page = find_lock_page(mapping, index); 253 if (!page) { 254 page = read_mapping_page(mapping, index, NULL); 255 256 if (IS_ERR(page)) { 257 printk(KERN_ERR "ufs_change_blocknr: " 258 "read_mapping_page error: ino %lu, index: %lu\n", 259 mapping->host->i_ino, index); 260 goto out; 261 } 262 263 lock_page(page); 264 265 if (unlikely(page->mapping == NULL)) { 266 /* Truncate got there first */ 267 unlock_page(page); 268 page_cache_release(page); 269 page = NULL; 270 goto out; 271 } 272 273 if (!PageUptodate(page) || PageError(page)) { 274 unlock_page(page); 275 page_cache_release(page); 276 277 printk(KERN_ERR "ufs_change_blocknr: " 278 "can not read page: ino %lu, index: %lu\n", 279 mapping->host->i_ino, index); 280 281 page = ERR_PTR(-EIO); 282 } 283 } 284out: 285 return page; 286} 287