]> git.ipfire.org Git - thirdparty/kernel/linux.git/blame - fs/ufs/inode.c
projects / thirdparty / kernel / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] ext3 filesystem bogus ENOSPC with reservation fix
[thirdparty/kernel/linux.git] / fs / ufs / inode.c
CommitLineData
1da177e4
LT		 1/*
2 * linux/fs/ufs/inode.c
3 *
4 * Copyright (C) 1998
5 * Daniel Pirkl <daniel.pirkl@email.cz>
6 * Charles University, Faculty of Mathematics and Physics
7 *
8 * from
9 *
10 * linux/fs/ext2/inode.c
11 *
12 * Copyright (C) 1992, 1993, 1994, 1995
13 * Remy Card (card@masi.ibp.fr)
14 * Laboratoire MASI - Institut Blaise Pascal
15 * Universite Pierre et Marie Curie (Paris VI)
16 *
17 * from
18 *
19 * linux/fs/minix/inode.c
20 *
21 * Copyright (C) 1991, 1992 Linus Torvalds
22 *
23 * Goal-directed block allocation by Stephen Tweedie (sct@dcs.ed.ac.uk), 1993
24 * Big-endian to little-endian byte-swapping/bitmaps by
25 * David S. Miller (davem@caip.rutgers.edu), 1995
26 */
27
28#include <asm/uaccess.h>
29#include <asm/system.h>
30
31#include <linux/errno.h>
32#include <linux/fs.h>
33#include <linux/ufs_fs.h>
34#include <linux/time.h>
35#include <linux/stat.h>
36#include <linux/string.h>
37#include <linux/mm.h>
38#include <linux/smp_lock.h>
39#include <linux/buffer_head.h>
40
41#include "swab.h"
42#include "util.h"
43
138bb68a
AB		 44static u64 ufs_frag_map(struct inode *inode, sector_t frag);
45
1da177e4
LT		 46static int ufs_block_to_path(struct inode *inode, sector_t i_block, sector_t offsets[4])
47{
48 struct ufs_sb_private_info *uspi = UFS_SB(inode->i_sb)->s_uspi;
49 int ptrs = uspi->s_apb;
50 int ptrs_bits = uspi->s_apbshift;
51 const long direct_blocks = UFS_NDADDR,
52 indirect_blocks = ptrs,
53 double_blocks = (1 << (ptrs_bits * 2));
54 int n = 0;
55
56
abf5d15f 57 UFSD("ptrs=uspi->s_apb = %d,double_blocks=%ld \n",ptrs,double_blocks);
1da177e4
LT		 58 if (i_block < 0) {
59 ufs_warning(inode->i_sb, "ufs_block_to_path", "block < 0");
60 } else if (i_block < direct_blocks) {
61 offsets[n++] = i_block;
62 } else if ((i_block -= direct_blocks) < indirect_blocks) {
63 offsets[n++] = UFS_IND_BLOCK;
64 offsets[n++] = i_block;
65 } else if ((i_block -= indirect_blocks) < double_blocks) {
66 offsets[n++] = UFS_DIND_BLOCK;
67 offsets[n++] = i_block >> ptrs_bits;
68 offsets[n++] = i_block & (ptrs - 1);
69 } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
70 offsets[n++] = UFS_TIND_BLOCK;
71 offsets[n++] = i_block >> (ptrs_bits * 2);
72 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
73 offsets[n++] = i_block & (ptrs - 1);
74 } else {
75 ufs_warning(inode->i_sb, "ufs_block_to_path", "block > big");
76 }
77 return n;
78}
79
80/*
81 * Returns the location of the fragment from
82 * the begining of the filesystem.
83 */
84
138bb68a 85static u64 ufs_frag_map(struct inode *inode, sector_t frag)
1da177e4
LT		 86{
87 struct ufs_inode_info *ufsi = UFS_I(inode);
88 struct super_block *sb = inode->i_sb;
89 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
90 u64 mask = (u64) uspi->s_apbmask>>uspi->s_fpbshift;
91 int shift = uspi->s_apbshift-uspi->s_fpbshift;
92 sector_t offsets[4], *p;
93 int depth = ufs_block_to_path(inode, frag >> uspi->s_fpbshift, offsets);
94 u64 ret = 0L;
95 __fs32 block;
96 __fs64 u2_block = 0L;
97 unsigned flags = UFS_SB(sb)->s_flags;
98 u64 temp = 0L;
99
abf5d15f 100 UFSD(": frag = %llu depth = %d\n", (unsigned long long)frag, depth);
7256d819
AM		 101 UFSD(": uspi->s_fpbshift = %d ,uspi->s_apbmask = %x, mask=%llx\n",
102 uspi->s_fpbshift, uspi->s_apbmask,
103 (unsigned long long)mask);
1da177e4
LT		 104
105 if (depth == 0)
106 return 0;
107
108 p = offsets;
109
110 lock_kernel();
111 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
112 goto ufs2;
113
114 block = ufsi->i_u1.i_data[*p++];
115 if (!block)
116 goto out;
117 while (--depth) {
118 struct buffer_head *bh;
119 sector_t n = *p++;
120
121 bh = sb_bread(sb, uspi->s_sbbase + fs32_to_cpu(sb, block)+(n>>shift));
122 if (!bh)
123 goto out;
124 block = ((__fs32 *) bh->b_data)[n & mask];
125 brelse (bh);
126 if (!block)
127 goto out;
128 }
129 ret = (u64) (uspi->s_sbbase + fs32_to_cpu(sb, block) + (frag & uspi->s_fpbmask));
130 goto out;
131ufs2:
132 u2_block = ufsi->i_u1.u2_i_data[*p++];
133 if (!u2_block)
134 goto out;
135
136
137 while (--depth) {
138 struct buffer_head *bh;
139 sector_t n = *p++;
140
141
142 temp = (u64)(uspi->s_sbbase) + fs64_to_cpu(sb, u2_block);
143 bh = sb_bread(sb, temp +(u64) (n>>shift));
144 if (!bh)
145 goto out;
146 u2_block = ((__fs64 *)bh->b_data)[n & mask];
147 brelse(bh);
148 if (!u2_block)
149 goto out;
150 }
151 temp = (u64)uspi->s_sbbase + fs64_to_cpu(sb, u2_block);
152 ret = temp + (u64) (frag & uspi->s_fpbmask);
153
154out:
155 unlock_kernel();
156 return ret;
157}
158
022a6dc5 159static void ufs_clear_frag(struct inode *inode, struct buffer_head *bh)
c9a27b5d
ED		 160{
161 lock_buffer(bh);
162 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
163 set_buffer_uptodate(bh);
164 mark_buffer_dirty(bh);
165 unlock_buffer(bh);
166 if (IS_SYNC(inode))
167 sync_dirty_buffer(bh);
168}
169
022a6dc5
ED		 170static struct buffer_head *
171ufs_clear_frags(struct inode *inode, sector_t beg,
172 unsigned int n)
173{
174 struct buffer_head *res, *bh;
175 sector_t end = beg + n;
176
177 res = sb_getblk(inode->i_sb, beg);
178 ufs_clear_frag(inode, res);
179 for (++beg; beg < end; ++beg) {
180 bh = sb_getblk(inode->i_sb, beg);
181 ufs_clear_frag(inode, bh);
f3914758 182 brelse(bh);
022a6dc5
ED		 183 }
184 return res;
185}
186
187/**
188 * ufs_inode_getfrag() - allocate new fragment(s)
189 * @inode - pointer to inode
190 * @fragment - number of `fragment' which hold pointer
191 * to new allocated fragment(s)
192 * @new_fragment - number of new allocated fragment(s)
193 * @required - how many fragment(s) we require
194 * @err - we set it if something wrong
195 * @phys - pointer to where we save physical number of new allocated fragments,
196 * NULL if we allocate not data(indirect blocks for example).
197 * @new - we set it if we allocate new block
198 * @locked_page - for ufs_new_fragments()
199 */
200static struct buffer_head *
201ufs_inode_getfrag(struct inode *inode, unsigned int fragment,
202 sector_t new_fragment, unsigned int required, int *err,
203 long *phys, int *new, struct page *locked_page)
1da177e4
LT		 204{
205 struct ufs_inode_info *ufsi = UFS_I(inode);
022a6dc5
ED		 206 struct super_block *sb = inode->i_sb;
207 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
1da177e4
LT		 208 struct buffer_head * result;
209 unsigned block, blockoff, lastfrag, lastblock, lastblockoff;
210 unsigned tmp, goal;
211 __fs32 * p, * p2;
1da177e4 212
022a6dc5
ED		 213 UFSD("ENTER, ino %lu, fragment %u, new_fragment %llu, required %u, "
214 "metadata %d\n", inode->i_ino, fragment,
215 (unsigned long long)new_fragment, required, !phys);
1da177e4 216
1da177e4
LT		 217 /* TODO : to be done for write support
218 if ( (flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
219 goto ufs2;
220 */
221
222 block = ufs_fragstoblks (fragment);
223 blockoff = ufs_fragnum (fragment);
224 p = ufsi->i_u1.i_data + block;
225 goal = 0;
226
227repeat:
228 tmp = fs32_to_cpu(sb, *p);
229 lastfrag = ufsi->i_lastfrag;
230 if (tmp && fragment < lastfrag) {
022a6dc5 231 if (!phys) {
1da177e4
LT		 232 result = sb_getblk(sb, uspi->s_sbbase + tmp + blockoff);
233 if (tmp == fs32_to_cpu(sb, *p)) {
abf5d15f 234 UFSD("EXIT, result %u\n", tmp + blockoff);
1da177e4
LT		 235 return result;
236 }
237 brelse (result);
238 goto repeat;
239 } else {
c9a27b5d 240 *phys = tmp + blockoff;
1da177e4
LT		 241 return NULL;
242 }
243 }
244
245 lastblock = ufs_fragstoblks (lastfrag);
246 lastblockoff = ufs_fragnum (lastfrag);
247 /*
248 * We will extend file into new block beyond last allocated block
249 */
250 if (lastblock < block) {
251 /*
252 * We must reallocate last allocated block
253 */
254 if (lastblockoff) {
255 p2 = ufsi->i_u1.i_data + lastblock;
256 tmp = ufs_new_fragments (inode, p2, lastfrag,
6ef4d6bf
ED		 257 fs32_to_cpu(sb, *p2), uspi->s_fpb - lastblockoff,
258 err, locked_page);
1da177e4
LT		 259 if (!tmp) {
260 if (lastfrag != ufsi->i_lastfrag)
261 goto repeat;
262 else
263 return NULL;
264 }
265 lastfrag = ufsi->i_lastfrag;
266
267 }
268 goal = fs32_to_cpu(sb, ufsi->i_u1.i_data[lastblock]) + uspi->s_fpb;
269 tmp = ufs_new_fragments (inode, p, fragment - blockoff,
6ef4d6bf
ED		 270 goal, required + blockoff,
271 err, locked_page);
1da177e4
LT		 272 }
273 /*
274 * We will extend last allocated block
275 */
276 else if (lastblock == block) {
6ef4d6bf
ED		 277 tmp = ufs_new_fragments(inode, p, fragment - (blockoff - lastblockoff),
278 fs32_to_cpu(sb, *p), required + (blockoff - lastblockoff),
279 err, locked_page);
1da177e4
LT		 280 }
281 /*
282 * We will allocate new block before last allocated block
283 */
284 else /* (lastblock > block) */ {
285 if (lastblock && (tmp = fs32_to_cpu(sb, ufsi->i_u1.i_data[lastblock-1])))
286 goal = tmp + uspi->s_fpb;
6ef4d6bf
ED		 287 tmp = ufs_new_fragments(inode, p, fragment - blockoff,
288 goal, uspi->s_fpb, err, locked_page);
1da177e4
LT		 289 }
290 if (!tmp) {
291 if ((!blockoff && *p) ||
292 (blockoff && lastfrag != ufsi->i_lastfrag))
293 goto repeat;
294 *err = -ENOSPC;
295 return NULL;
296 }
297
022a6dc5
ED		 298 if (!phys) {
299 result = ufs_clear_frags(inode, tmp + blockoff, required);
1da177e4 300 } else {
c9a27b5d 301 *phys = tmp + blockoff;
1da177e4
LT		 302 result = NULL;
303 *err = 0;
304 *new = 1;
305 }
306
307 inode->i_ctime = CURRENT_TIME_SEC;
308 if (IS_SYNC(inode))
309 ufs_sync_inode (inode);
310 mark_inode_dirty(inode);
abf5d15f 311 UFSD("EXIT, result %u\n", tmp + blockoff);
1da177e4
LT		 312 return result;
313
314 /* This part : To be implemented ....
315 Required only for writing, not required for READ-ONLY.
316ufs2:
317
318 u2_block = ufs_fragstoblks(fragment);
319 u2_blockoff = ufs_fragnum(fragment);
320 p = ufsi->i_u1.u2_i_data + block;
321 goal = 0;
322
323repeat2:
324 tmp = fs32_to_cpu(sb, *p);
325 lastfrag = ufsi->i_lastfrag;
326
327 */
328}
329
022a6dc5
ED		 330/**
331 * ufs_inode_getblock() - allocate new block
332 * @inode - pointer to inode
333 * @bh - pointer to block which hold "pointer" to new allocated block
334 * @fragment - number of `fragment' which hold pointer
335 * to new allocated block
336 * @new_fragment - number of new allocated fragment
337 * (block will hold this fragment and also uspi->s_fpb-1)
338 * @err - see ufs_inode_getfrag()
339 * @phys - see ufs_inode_getfrag()
340 * @new - see ufs_inode_getfrag()
341 * @locked_page - see ufs_inode_getfrag()
342 */
343static struct buffer_head *
344ufs_inode_getblock(struct inode *inode, struct buffer_head *bh,
345 unsigned int fragment, sector_t new_fragment, int *err,
346 long *phys, int *new, struct page *locked_page)
1da177e4 347{
022a6dc5
ED		 348 struct super_block *sb = inode->i_sb;
349 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
1da177e4
LT		 350 struct buffer_head * result;
351 unsigned tmp, goal, block, blockoff;
352 __fs32 * p;
353
1da177e4
LT		 354 block = ufs_fragstoblks (fragment);
355 blockoff = ufs_fragnum (fragment);
356
022a6dc5
ED		 357 UFSD("ENTER, ino %lu, fragment %u, new_fragment %llu, metadata %d\n",
358 inode->i_ino, fragment, (unsigned long long)new_fragment, !phys);
1da177e4
LT		 359
360 result = NULL;
361 if (!bh)
362 goto out;
363 if (!buffer_uptodate(bh)) {
364 ll_rw_block (READ, 1, &bh);
365 wait_on_buffer (bh);
366 if (!buffer_uptodate(bh))
367 goto out;
368 }
369
370 p = (__fs32 *) bh->b_data + block;
371repeat:
372 tmp = fs32_to_cpu(sb, *p);
373 if (tmp) {
022a6dc5 374 if (!phys) {
1da177e4
LT		 375 result = sb_getblk(sb, uspi->s_sbbase + tmp + blockoff);
376 if (tmp == fs32_to_cpu(sb, *p))
377 goto out;
378 brelse (result);
379 goto repeat;
380 } else {
c9a27b5d 381 *phys = tmp + blockoff;
1da177e4
LT		 382 goto out;
383 }
384 }
385
386 if (block && (tmp = fs32_to_cpu(sb, ((__fs32*)bh->b_data)[block-1]) + uspi->s_fpb))
387 goal = tmp + uspi->s_fpb;
388 else
389 goal = bh->b_blocknr + uspi->s_fpb;
6ef4d6bf
ED		 390 tmp = ufs_new_fragments(inode, p, ufs_blknum(new_fragment), goal,
391 uspi->s_fpb, err, locked_page);
1da177e4
LT		 392 if (!tmp) {
393 if (fs32_to_cpu(sb, *p))
394 goto repeat;
395 goto out;
396 }
397
c9a27b5d 398
022a6dc5
ED		 399 if (!phys) {
400 result = ufs_clear_frags(inode, tmp + blockoff, uspi->s_fpb);
1da177e4 401 } else {
c9a27b5d 402 *phys = tmp + blockoff;
1da177e4
LT		 403 *new = 1;
404 }
405
406 mark_buffer_dirty(bh);
407 if (IS_SYNC(inode))
408 sync_dirty_buffer(bh);
409 inode->i_ctime = CURRENT_TIME_SEC;
410 mark_inode_dirty(inode);
abf5d15f 411 UFSD("result %u\n", tmp + blockoff);
1da177e4
LT		 412out:
413 brelse (bh);
abf5d15f 414 UFSD("EXIT\n");
1da177e4
LT		 415 return result;
416}
417
022a6dc5
ED		 418/**
419 * ufs_getfrag_bloc() - `get_block_t' function, interface between UFS and
420 * readpage, writepage and so on
1da177e4
LT		 421 */
422
022a6dc5 423int ufs_getfrag_block(struct inode *inode, sector_t fragment, struct buffer_head *bh_result, int create)
1da177e4
LT		 424{
425 struct super_block * sb = inode->i_sb;
426 struct ufs_sb_private_info * uspi = UFS_SB(sb)->s_uspi;
427 struct buffer_head * bh;
428 int ret, err, new;
429 unsigned long ptr,phys;
430 u64 phys64 = 0;
431
432 if (!create) {
433 phys64 = ufs_frag_map(inode, fragment);
7256d819 434 UFSD("phys64 = %llu\n", (unsigned long long)phys64);
1da177e4
LT		 435 if (phys64)
436 map_bh(bh_result, sb, phys64);
437 return 0;
438 }
439
440 /* This code entered only while writing ....? */
441
442 err = -EIO;
443 new = 0;
444 ret = 0;
445 bh = NULL;
446
447 lock_kernel();
448
abf5d15f 449 UFSD("ENTER, ino %lu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment);
1da177e4
LT		 450 if (fragment < 0)
451 goto abort_negative;
452 if (fragment >
453 ((UFS_NDADDR + uspi->s_apb + uspi->s_2apb + uspi->s_3apb)
454 << uspi->s_fpbshift))
455 goto abort_too_big;
456
457 err = 0;
458 ptr = fragment;
459
460 /*
461 * ok, these macros clean the logic up a bit and make
462 * it much more readable:
463 */
464#define GET_INODE_DATABLOCK(x) \
022a6dc5 465 ufs_inode_getfrag(inode, x, fragment, 1, &err, &phys, &new, bh_result->b_page)
1da177e4 466#define GET_INODE_PTR(x) \
022a6dc5 467 ufs_inode_getfrag(inode, x, fragment, uspi->s_fpb, &err, NULL, NULL, bh_result->b_page)
1da177e4 468#define GET_INDIRECT_DATABLOCK(x) \
022a6dc5
ED		 469 ufs_inode_getblock(inode, bh, x, fragment, \
470 &err, &phys, &new, bh_result->b_page);
1da177e4 471#define GET_INDIRECT_PTR(x) \
022a6dc5
ED		 472 ufs_inode_getblock(inode, bh, x, fragment, \
473 &err, NULL, NULL, bh_result->b_page);
1da177e4
LT		 474
475 if (ptr < UFS_NDIR_FRAGMENT) {
476 bh = GET_INODE_DATABLOCK(ptr);
477 goto out;
478 }
479 ptr -= UFS_NDIR_FRAGMENT;
480 if (ptr < (1 << (uspi->s_apbshift + uspi->s_fpbshift))) {
481 bh = GET_INODE_PTR(UFS_IND_FRAGMENT + (ptr >> uspi->s_apbshift));
482 goto get_indirect;
483 }
484 ptr -= 1 << (uspi->s_apbshift + uspi->s_fpbshift);
485 if (ptr < (1 << (uspi->s_2apbshift + uspi->s_fpbshift))) {
486 bh = GET_INODE_PTR(UFS_DIND_FRAGMENT + (ptr >> uspi->s_2apbshift));
487 goto get_double;
488 }
489 ptr -= 1 << (uspi->s_2apbshift + uspi->s_fpbshift);
490 bh = GET_INODE_PTR(UFS_TIND_FRAGMENT + (ptr >> uspi->s_3apbshift));
491 bh = GET_INDIRECT_PTR((ptr >> uspi->s_2apbshift) & uspi->s_apbmask);
492get_double:
493 bh = GET_INDIRECT_PTR((ptr >> uspi->s_apbshift) & uspi->s_apbmask);
494get_indirect:
495 bh = GET_INDIRECT_DATABLOCK(ptr & uspi->s_apbmask);
496
497#undef GET_INODE_DATABLOCK
498#undef GET_INODE_PTR
499#undef GET_INDIRECT_DATABLOCK
500#undef GET_INDIRECT_PTR
501
502out:
503 if (err)
504 goto abort;
505 if (new)
506 set_buffer_new(bh_result);
507 map_bh(bh_result, sb, phys);
508abort:
509 unlock_kernel();
510 return err;
511
512abort_negative:
513 ufs_warning(sb, "ufs_get_block", "block < 0");
514 goto abort;
515
516abort_too_big:
517 ufs_warning(sb, "ufs_get_block", "block > big");
518 goto abort;
519}
520
138bb68a
AB		 521static struct buffer_head *ufs_getfrag(struct inode *inode,
522 unsigned int fragment,
523 int create, int *err)
1da177e4
LT		 524{
525 struct buffer_head dummy;
526 int error;
527
528 dummy.b_state = 0;
529 dummy.b_blocknr = -1000;
530 error = ufs_getfrag_block(inode, fragment, &dummy, create);
531 *err = error;
532 if (!error && buffer_mapped(&dummy)) {
533 struct buffer_head *bh;
534 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
535 if (buffer_new(&dummy)) {
536 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
537 set_buffer_uptodate(bh);
538 mark_buffer_dirty(bh);
539 }
540 return bh;
541 }
542 return NULL;
543}
544
545struct buffer_head * ufs_bread (struct inode * inode, unsigned fragment,
546 int create, int * err)
547{
548 struct buffer_head * bh;
549
abf5d15f 550 UFSD("ENTER, ino %lu, fragment %u\n", inode->i_ino, fragment);
1da177e4
LT		 551 bh = ufs_getfrag (inode, fragment, create, err);
552 if (!bh || buffer_uptodate(bh))
553 return bh;
554 ll_rw_block (READ, 1, &bh);
555 wait_on_buffer (bh);
556 if (buffer_uptodate(bh))
557 return bh;
558 brelse (bh);
559 *err = -EIO;
560 return NULL;
561}
562
563static int ufs_writepage(struct page *page, struct writeback_control *wbc)
564{
565 return block_write_full_page(page,ufs_getfrag_block,wbc);
566}
567static int ufs_readpage(struct file *file, struct page *page)
568{
569 return block_read_full_page(page,ufs_getfrag_block);
570}
571static int ufs_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
572{
573 return block_prepare_write(page,from,to,ufs_getfrag_block);
574}
575static sector_t ufs_bmap(struct address_space *mapping, sector_t block)
576{
577 return generic_block_bmap(mapping,block,ufs_getfrag_block);
578}
f5e54d6e 579const struct address_space_operations ufs_aops = {
1da177e4
LT		 580 .readpage = ufs_readpage,
581 .writepage = ufs_writepage,
582 .sync_page = block_sync_page,
583 .prepare_write = ufs_prepare_write,
584 .commit_write = generic_commit_write,
585 .bmap = ufs_bmap
586};
587
826843a3
ED		 588static void ufs_set_inode_ops(struct inode *inode)
589{
590 if (S_ISREG(inode->i_mode)) {
591 inode->i_op = &ufs_file_inode_operations;
592 inode->i_fop = &ufs_file_operations;
593 inode->i_mapping->a_ops = &ufs_aops;
594 } else if (S_ISDIR(inode->i_mode)) {
595 inode->i_op = &ufs_dir_inode_operations;
596 inode->i_fop = &ufs_dir_operations;
597 inode->i_mapping->a_ops = &ufs_aops;
598 } else if (S_ISLNK(inode->i_mode)) {
599 if (!inode->i_blocks)
600 inode->i_op = &ufs_fast_symlink_inode_operations;
601 else {
602 inode->i_op = &page_symlink_inode_operations;
603 inode->i_mapping->a_ops = &ufs_aops;
604 }
605 } else
606 init_special_inode(inode, inode->i_mode,
607 ufs_get_inode_dev(inode->i_sb, UFS_I(inode)));
608}
609
05f225dc 610static void ufs1_read_inode(struct inode *inode, struct ufs_inode *ufs_inode)
1da177e4
LT		 611{
612 struct ufs_inode_info *ufsi = UFS_I(inode);
05f225dc 613 struct super_block *sb = inode->i_sb;
1da177e4
LT		 614 mode_t mode;
615 unsigned i;
1da177e4
LT		 616
617 /*
618 * Copy data to the in-core inode.
619 */
620 inode->i_mode = mode = fs16_to_cpu(sb, ufs_inode->ui_mode);
621 inode->i_nlink = fs16_to_cpu(sb, ufs_inode->ui_nlink);
622 if (inode->i_nlink == 0)
623 ufs_error (sb, "ufs_read_inode", "inode %lu has zero nlink\n", inode->i_ino);
624
625 /*
626 * Linux now has 32-bit uid and gid, so we can support EFT.
627 */
628 inode->i_uid = ufs_get_inode_uid(sb, ufs_inode);
629 inode->i_gid = ufs_get_inode_gid(sb, ufs_inode);
630
631 inode->i_size = fs64_to_cpu(sb, ufs_inode->ui_size);
632 inode->i_atime.tv_sec = fs32_to_cpu(sb, ufs_inode->ui_atime.tv_sec);
633 inode->i_ctime.tv_sec = fs32_to_cpu(sb, ufs_inode->ui_ctime.tv_sec);
634 inode->i_mtime.tv_sec = fs32_to_cpu(sb, ufs_inode->ui_mtime.tv_sec);
635 inode->i_mtime.tv_nsec = 0;
636 inode->i_atime.tv_nsec = 0;
637 inode->i_ctime.tv_nsec = 0;
638 inode->i_blocks = fs32_to_cpu(sb, ufs_inode->ui_blocks);
1da177e4
LT		 639 ufsi->i_flags = fs32_to_cpu(sb, ufs_inode->ui_flags);
640 ufsi->i_gen = fs32_to_cpu(sb, ufs_inode->ui_gen);
641 ufsi->i_shadow = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_shadow);
642 ufsi->i_oeftflag = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_oeftflag);
05f225dc 643
1da177e4
LT		 644
645 if (S_ISCHR(mode) || S_ISBLK(mode) || inode->i_blocks) {
646 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR); i++)
647 ufsi->i_u1.i_data[i] = ufs_inode->ui_u2.ui_addr.ui_db[i];
dd187a26 648 } else {
1da177e4
LT		 649 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR) * 4; i++)
650 ufsi->i_u1.i_symlink[i] = ufs_inode->ui_u2.ui_symlink[i];
651 }
05f225dc 652}
1da177e4 653
05f225dc
ED		 654static void ufs2_read_inode(struct inode *inode, struct ufs2_inode *ufs2_inode)
655{
656 struct ufs_inode_info *ufsi = UFS_I(inode);
657 struct super_block *sb = inode->i_sb;
658 mode_t mode;
659 unsigned i;
1da177e4 660
abf5d15f 661 UFSD("Reading ufs2 inode, ino %lu\n", inode->i_ino);
1da177e4
LT		 662 /*
663 * Copy data to the in-core inode.
664 */
665 inode->i_mode = mode = fs16_to_cpu(sb, ufs2_inode->ui_mode);
666 inode->i_nlink = fs16_to_cpu(sb, ufs2_inode->ui_nlink);
667 if (inode->i_nlink == 0)
668 ufs_error (sb, "ufs_read_inode", "inode %lu has zero nlink\n", inode->i_ino);
669
670 /*
671 * Linux now has 32-bit uid and gid, so we can support EFT.
672 */
673 inode->i_uid = fs32_to_cpu(sb, ufs2_inode->ui_uid);
674 inode->i_gid = fs32_to_cpu(sb, ufs2_inode->ui_gid);
675
676 inode->i_size = fs64_to_cpu(sb, ufs2_inode->ui_size);
677 inode->i_atime.tv_sec = fs32_to_cpu(sb, ufs2_inode->ui_atime.tv_sec);
678 inode->i_ctime.tv_sec = fs32_to_cpu(sb, ufs2_inode->ui_ctime.tv_sec);
679 inode->i_mtime.tv_sec = fs32_to_cpu(sb, ufs2_inode->ui_mtime.tv_sec);
680 inode->i_mtime.tv_nsec = 0;
681 inode->i_atime.tv_nsec = 0;
682 inode->i_ctime.tv_nsec = 0;
683 inode->i_blocks = fs64_to_cpu(sb, ufs2_inode->ui_blocks);
1da177e4
LT		 684 ufsi->i_flags = fs32_to_cpu(sb, ufs2_inode->ui_flags);
685 ufsi->i_gen = fs32_to_cpu(sb, ufs2_inode->ui_gen);
686 /*
687 ufsi->i_shadow = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_shadow);
688 ufsi->i_oeftflag = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_oeftflag);
689 */
1da177e4
LT		 690
691 if (S_ISCHR(mode) || S_ISBLK(mode) || inode->i_blocks) {
692 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR); i++)
693 ufsi->i_u1.u2_i_data[i] =
694 ufs2_inode->ui_u2.ui_addr.ui_db[i];
05f225dc 695 } else {
1da177e4
LT		 696 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR) * 4; i++)
697 ufsi->i_u1.i_symlink[i] = ufs2_inode->ui_u2.ui_symlink[i];
698 }
05f225dc
ED		 699}
700
701void ufs_read_inode(struct inode * inode)
702{
703 struct ufs_inode_info *ufsi = UFS_I(inode);
704 struct super_block * sb;
705 struct ufs_sb_private_info * uspi;
706 struct buffer_head * bh;
707
708 UFSD("ENTER, ino %lu\n", inode->i_ino);
709
710 sb = inode->i_sb;
711 uspi = UFS_SB(sb)->s_uspi;
712
713 if (inode->i_ino < UFS_ROOTINO ||
714 inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
715 ufs_warning(sb, "ufs_read_inode", "bad inode number (%lu)\n",
716 inode->i_ino);
717 goto bad_inode;
718 }
719
720 bh = sb_bread(sb, uspi->s_sbbase + ufs_inotofsba(inode->i_ino));
721 if (!bh) {
722 ufs_warning(sb, "ufs_read_inode", "unable to read inode %lu\n",
723 inode->i_ino);
724 goto bad_inode;
725 }
726 if ((UFS_SB(sb)->s_flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
727 struct ufs2_inode *ufs2_inode = (struct ufs2_inode *)bh->b_data;
728
729 ufs2_read_inode(inode,
730 ufs2_inode + ufs_inotofsbo(inode->i_ino));
731 } else {
732 struct ufs_inode *ufs_inode = (struct ufs_inode *)bh->b_data;
733
734 ufs1_read_inode(inode, ufs_inode + ufs_inotofsbo(inode->i_ino));
735 }
736
737 inode->i_blksize = PAGE_SIZE;/*This is the optimal IO size (for stat)*/
738 inode->i_version++;
739 ufsi->i_lastfrag =
740 (inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift;
741 ufsi->i_dir_start_lookup = 0;
1da177e4
LT		 742 ufsi->i_osync = 0;
743
826843a3 744 ufs_set_inode_ops(inode);
1da177e4
LT		 745
746 brelse(bh);
747
abf5d15f 748 UFSD("EXIT\n");
1da177e4 749 return;
05f225dc
ED		 750
751bad_inode:
752 make_bad_inode(inode);
1da177e4
LT		 753}
754
755static int ufs_update_inode(struct inode * inode, int do_sync)
756{
757 struct ufs_inode_info *ufsi = UFS_I(inode);
758 struct super_block * sb;
759 struct ufs_sb_private_info * uspi;
760 struct buffer_head * bh;
761 struct ufs_inode * ufs_inode;
762 unsigned i;
763 unsigned flags;
764
abf5d15f 765 UFSD("ENTER, ino %lu\n", inode->i_ino);
1da177e4
LT		 766
767 sb = inode->i_sb;
768 uspi = UFS_SB(sb)->s_uspi;
769 flags = UFS_SB(sb)->s_flags;
770
771 if (inode->i_ino < UFS_ROOTINO ||
772 inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
773 ufs_warning (sb, "ufs_read_inode", "bad inode number (%lu)\n", inode->i_ino);
774 return -1;
775 }
776
777 bh = sb_bread(sb, ufs_inotofsba(inode->i_ino));
778 if (!bh) {
779 ufs_warning (sb, "ufs_read_inode", "unable to read inode %lu\n", inode->i_ino);
780 return -1;
781 }
782 ufs_inode = (struct ufs_inode *) (bh->b_data + ufs_inotofsbo(inode->i_ino) * sizeof(struct ufs_inode));
783
784 ufs_inode->ui_mode = cpu_to_fs16(sb, inode->i_mode);
785 ufs_inode->ui_nlink = cpu_to_fs16(sb, inode->i_nlink);
786
787 ufs_set_inode_uid(sb, ufs_inode, inode->i_uid);
788 ufs_set_inode_gid(sb, ufs_inode, inode->i_gid);
789
790 ufs_inode->ui_size = cpu_to_fs64(sb, inode->i_size);
791 ufs_inode->ui_atime.tv_sec = cpu_to_fs32(sb, inode->i_atime.tv_sec);
792 ufs_inode->ui_atime.tv_usec = 0;
793 ufs_inode->ui_ctime.tv_sec = cpu_to_fs32(sb, inode->i_ctime.tv_sec);
794 ufs_inode->ui_ctime.tv_usec = 0;
795 ufs_inode->ui_mtime.tv_sec = cpu_to_fs32(sb, inode->i_mtime.tv_sec);
796 ufs_inode->ui_mtime.tv_usec = 0;
797 ufs_inode->ui_blocks = cpu_to_fs32(sb, inode->i_blocks);
798 ufs_inode->ui_flags = cpu_to_fs32(sb, ufsi->i_flags);
799 ufs_inode->ui_gen = cpu_to_fs32(sb, ufsi->i_gen);
800
801 if ((flags & UFS_UID_MASK) == UFS_UID_EFT) {
802 ufs_inode->ui_u3.ui_sun.ui_shadow = cpu_to_fs32(sb, ufsi->i_shadow);
803 ufs_inode->ui_u3.ui_sun.ui_oeftflag = cpu_to_fs32(sb, ufsi->i_oeftflag);
804 }
805
806 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
807 /* ufs_inode->ui_u2.ui_addr.ui_db[0] = cpu_to_fs32(sb, inode->i_rdev); */
808 ufs_inode->ui_u2.ui_addr.ui_db[0] = ufsi->i_u1.i_data[0];
809 } else if (inode->i_blocks) {
810 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR); i++)
811 ufs_inode->ui_u2.ui_addr.ui_db[i] = ufsi->i_u1.i_data[i];
812 }
813 else {
814 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR) * 4; i++)
815 ufs_inode->ui_u2.ui_symlink[i] = ufsi->i_u1.i_symlink[i];
816 }
817
818 if (!inode->i_nlink)
819 memset (ufs_inode, 0, sizeof(struct ufs_inode));
820
821 mark_buffer_dirty(bh);
822 if (do_sync)
823 sync_dirty_buffer(bh);
824 brelse (bh);
825
abf5d15f 826 UFSD("EXIT\n");
1da177e4
LT		 827 return 0;
828}
829
830int ufs_write_inode (struct inode * inode, int wait)
831{
832 int ret;
833 lock_kernel();
834 ret = ufs_update_inode (inode, wait);
835 unlock_kernel();
836 return ret;
837}
838
839int ufs_sync_inode (struct inode *inode)
840{
841 return ufs_update_inode (inode, 1);
842}
843
844void ufs_delete_inode (struct inode * inode)
845{
10e5dce0
ED		 846 loff_t old_i_size;
847
fef26658 848 truncate_inode_pages(&inode->i_data, 0);
1da177e4
LT		 849 /*UFS_I(inode)->i_dtime = CURRENT_TIME;*/
850 lock_kernel();
851 mark_inode_dirty(inode);
852 ufs_update_inode(inode, IS_SYNC(inode));
10e5dce0 853 old_i_size = inode->i_size;
1da177e4 854 inode->i_size = 0;
10e5dce0
ED		 855 if (inode->i_blocks && ufs_truncate(inode, old_i_size))
856 ufs_warning(inode->i_sb, __FUNCTION__, "ufs_truncate failed\n");
1da177e4
LT		 857 ufs_free_inode (inode);
858 unlock_kernel();
859}
A mirror of Linus' kernel repository