1 // SPDX-License-Identifier: GPL-2.0 1 // SPDX-License-Identifier: GPL-2.0
2 /* 2 /*
3 * linux/fs/ufs/inode.c 3 * linux/fs/ufs/inode.c
4 * 4 *
5 * Copyright (C) 1998 5 * Copyright (C) 1998
6 * Daniel Pirkl <daniel.pirkl@email.cz> 6 * Daniel Pirkl <daniel.pirkl@email.cz>
7 * Charles University, Faculty of Mathematics 7 * Charles University, Faculty of Mathematics and Physics
8 * 8 *
9 * from 9 * from
10 * 10 *
11 * linux/fs/ext2/inode.c 11 * linux/fs/ext2/inode.c
12 * 12 *
13 * Copyright (C) 1992, 1993, 1994, 1995 13 * Copyright (C) 1992, 1993, 1994, 1995
14 * Remy Card (card@masi.ibp.fr) 14 * Remy Card (card@masi.ibp.fr)
15 * Laboratoire MASI - Institut Blaise Pascal 15 * Laboratoire MASI - Institut Blaise Pascal
16 * Universite Pierre et Marie Curie (Paris VI) 16 * Universite Pierre et Marie Curie (Paris VI)
17 * 17 *
18 * from 18 * from
19 * 19 *
20 * linux/fs/minix/inode.c 20 * linux/fs/minix/inode.c
21 * 21 *
22 * Copyright (C) 1991, 1992 Linus Torvalds 22 * Copyright (C) 1991, 1992 Linus Torvalds
23 * 23 *
24 * Goal-directed block allocation by Stephen 24 * Goal-directed block allocation by Stephen Tweedie (sct@dcs.ed.ac.uk), 1993
25 * Big-endian to little-endian byte-swapping/ 25 * Big-endian to little-endian byte-swapping/bitmaps by
26 * David S. Miller (davem@caip.rutgers. 26 * David S. Miller (davem@caip.rutgers.edu), 1995
27 */ 27 */
28 28
29 #include <linux/uaccess.h> 29 #include <linux/uaccess.h>
30 30
31 #include <linux/errno.h> 31 #include <linux/errno.h>
32 #include <linux/fs.h> 32 #include <linux/fs.h>
33 #include <linux/time.h> 33 #include <linux/time.h>
34 #include <linux/stat.h> 34 #include <linux/stat.h>
35 #include <linux/string.h> 35 #include <linux/string.h>
36 #include <linux/mm.h> 36 #include <linux/mm.h>
37 #include <linux/buffer_head.h> 37 #include <linux/buffer_head.h>
38 #include <linux/mpage.h> <<
39 #include <linux/writeback.h> 38 #include <linux/writeback.h>
40 #include <linux/iversion.h> <<
41 39
42 #include "ufs_fs.h" 40 #include "ufs_fs.h"
43 #include "ufs.h" 41 #include "ufs.h"
44 #include "swab.h" 42 #include "swab.h"
45 #include "util.h" 43 #include "util.h"
46 44
47 static int ufs_block_to_path(struct inode *ino 45 static int ufs_block_to_path(struct inode *inode, sector_t i_block, unsigned offsets[4])
48 { 46 {
49 struct ufs_sb_private_info *uspi = UFS 47 struct ufs_sb_private_info *uspi = UFS_SB(inode->i_sb)->s_uspi;
50 int ptrs = uspi->s_apb; 48 int ptrs = uspi->s_apb;
51 int ptrs_bits = uspi->s_apbshift; 49 int ptrs_bits = uspi->s_apbshift;
52 const long direct_blocks = UFS_NDADDR, 50 const long direct_blocks = UFS_NDADDR,
53 indirect_blocks = ptrs, 51 indirect_blocks = ptrs,
54 double_blocks = (1 << (ptrs_bi 52 double_blocks = (1 << (ptrs_bits * 2));
55 int n = 0; 53 int n = 0;
56 54
57 55
58 UFSD("ptrs=uspi->s_apb = %d,double_blo 56 UFSD("ptrs=uspi->s_apb = %d,double_blocks=%ld \n",ptrs,double_blocks);
59 if (i_block < direct_blocks) { 57 if (i_block < direct_blocks) {
60 offsets[n++] = i_block; 58 offsets[n++] = i_block;
61 } else if ((i_block -= direct_blocks) 59 } else if ((i_block -= direct_blocks) < indirect_blocks) {
62 offsets[n++] = UFS_IND_BLOCK; 60 offsets[n++] = UFS_IND_BLOCK;
63 offsets[n++] = i_block; 61 offsets[n++] = i_block;
64 } else if ((i_block -= indirect_blocks 62 } else if ((i_block -= indirect_blocks) < double_blocks) {
65 offsets[n++] = UFS_DIND_BLOCK; 63 offsets[n++] = UFS_DIND_BLOCK;
66 offsets[n++] = i_block >> ptrs 64 offsets[n++] = i_block >> ptrs_bits;
67 offsets[n++] = i_block & (ptrs 65 offsets[n++] = i_block & (ptrs - 1);
68 } else if (((i_block -= double_blocks) 66 } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
69 offsets[n++] = UFS_TIND_BLOCK; 67 offsets[n++] = UFS_TIND_BLOCK;
70 offsets[n++] = i_block >> (ptr 68 offsets[n++] = i_block >> (ptrs_bits * 2);
71 offsets[n++] = (i_block >> ptr 69 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
72 offsets[n++] = i_block & (ptrs 70 offsets[n++] = i_block & (ptrs - 1);
73 } else { 71 } else {
74 ufs_warning(inode->i_sb, "ufs_ 72 ufs_warning(inode->i_sb, "ufs_block_to_path", "block > big");
75 } 73 }
76 return n; 74 return n;
77 } 75 }
78 76
79 typedef struct { 77 typedef struct {
80 void *p; 78 void *p;
81 union { 79 union {
82 __fs32 key32; 80 __fs32 key32;
83 __fs64 key64; 81 __fs64 key64;
84 }; 82 };
85 struct buffer_head *bh; 83 struct buffer_head *bh;
86 } Indirect; 84 } Indirect;
87 85
88 static inline int grow_chain32(struct ufs_inod 86 static inline int grow_chain32(struct ufs_inode_info *ufsi,
89 struct buffer_h 87 struct buffer_head *bh, __fs32 *v,
90 Indirect *from, 88 Indirect *from, Indirect *to)
91 { 89 {
92 Indirect *p; 90 Indirect *p;
93 unsigned seq; 91 unsigned seq;
94 to->bh = bh; 92 to->bh = bh;
95 do { 93 do {
96 seq = read_seqbegin(&ufsi->met 94 seq = read_seqbegin(&ufsi->meta_lock);
97 to->key32 = *(__fs32 *)(to->p 95 to->key32 = *(__fs32 *)(to->p = v);
98 for (p = from; p <= to && p->k 96 for (p = from; p <= to && p->key32 == *(__fs32 *)p->p; p++)
99 ; 97 ;
100 } while (read_seqretry(&ufsi->meta_loc 98 } while (read_seqretry(&ufsi->meta_lock, seq));
101 return (p > to); 99 return (p > to);
102 } 100 }
103 101
104 static inline int grow_chain64(struct ufs_inod 102 static inline int grow_chain64(struct ufs_inode_info *ufsi,
105 struct buffer_h 103 struct buffer_head *bh, __fs64 *v,
106 Indirect *from, 104 Indirect *from, Indirect *to)
107 { 105 {
108 Indirect *p; 106 Indirect *p;
109 unsigned seq; 107 unsigned seq;
110 to->bh = bh; 108 to->bh = bh;
111 do { 109 do {
112 seq = read_seqbegin(&ufsi->met 110 seq = read_seqbegin(&ufsi->meta_lock);
113 to->key64 = *(__fs64 *)(to->p 111 to->key64 = *(__fs64 *)(to->p = v);
114 for (p = from; p <= to && p->k 112 for (p = from; p <= to && p->key64 == *(__fs64 *)p->p; p++)
115 ; 113 ;
116 } while (read_seqretry(&ufsi->meta_loc 114 } while (read_seqretry(&ufsi->meta_lock, seq));
117 return (p > to); 115 return (p > to);
118 } 116 }
119 117
120 /* 118 /*
121 * Returns the location of the fragment from 119 * Returns the location of the fragment from
122 * the beginning of the filesystem. 120 * the beginning of the filesystem.
123 */ 121 */
124 122
125 static u64 ufs_frag_map(struct inode *inode, u 123 static u64 ufs_frag_map(struct inode *inode, unsigned offsets[4], int depth)
126 { 124 {
127 struct ufs_inode_info *ufsi = UFS_I(in 125 struct ufs_inode_info *ufsi = UFS_I(inode);
128 struct super_block *sb = inode->i_sb; 126 struct super_block *sb = inode->i_sb;
129 struct ufs_sb_private_info *uspi = UFS 127 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
130 u64 mask = (u64) uspi->s_apbmask>>uspi 128 u64 mask = (u64) uspi->s_apbmask>>uspi->s_fpbshift;
131 int shift = uspi->s_apbshift-uspi->s_f 129 int shift = uspi->s_apbshift-uspi->s_fpbshift;
132 Indirect chain[4], *q = chain; 130 Indirect chain[4], *q = chain;
133 unsigned *p; 131 unsigned *p;
134 unsigned flags = UFS_SB(sb)->s_flags; 132 unsigned flags = UFS_SB(sb)->s_flags;
135 u64 res = 0; 133 u64 res = 0;
136 134
137 UFSD(": uspi->s_fpbshift = %d ,uspi->s 135 UFSD(": uspi->s_fpbshift = %d ,uspi->s_apbmask = %x, mask=%llx\n",
138 uspi->s_fpbshift, uspi->s_apbm 136 uspi->s_fpbshift, uspi->s_apbmask,
139 (unsigned long long)mask); 137 (unsigned long long)mask);
140 138
141 if (depth == 0) 139 if (depth == 0)
142 goto no_block; 140 goto no_block;
143 141
144 again: 142 again:
145 p = offsets; 143 p = offsets;
146 144
147 if ((flags & UFS_TYPE_MASK) == UFS_TYP 145 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
148 goto ufs2; 146 goto ufs2;
149 147
150 if (!grow_chain32(ufsi, NULL, &ufsi->i 148 if (!grow_chain32(ufsi, NULL, &ufsi->i_u1.i_data[*p++], chain, q))
151 goto changed; 149 goto changed;
152 if (!q->key32) 150 if (!q->key32)
153 goto no_block; 151 goto no_block;
154 while (--depth) { 152 while (--depth) {
155 __fs32 *ptr; 153 __fs32 *ptr;
156 struct buffer_head *bh; 154 struct buffer_head *bh;
157 unsigned n = *p++; 155 unsigned n = *p++;
158 156
159 bh = sb_bread(sb, uspi->s_sbba 157 bh = sb_bread(sb, uspi->s_sbbase +
160 fs32_to_cpu( 158 fs32_to_cpu(sb, q->key32) + (n>>shift));
161 if (!bh) 159 if (!bh)
162 goto no_block; 160 goto no_block;
163 ptr = (__fs32 *)bh->b_data + ( 161 ptr = (__fs32 *)bh->b_data + (n & mask);
164 if (!grow_chain32(ufsi, bh, pt 162 if (!grow_chain32(ufsi, bh, ptr, chain, ++q))
165 goto changed; 163 goto changed;
166 if (!q->key32) 164 if (!q->key32)
167 goto no_block; 165 goto no_block;
168 } 166 }
169 res = fs32_to_cpu(sb, q->key32); 167 res = fs32_to_cpu(sb, q->key32);
170 goto found; 168 goto found;
171 169
172 ufs2: 170 ufs2:
173 if (!grow_chain64(ufsi, NULL, &ufsi->i 171 if (!grow_chain64(ufsi, NULL, &ufsi->i_u1.u2_i_data[*p++], chain, q))
174 goto changed; 172 goto changed;
175 if (!q->key64) 173 if (!q->key64)
176 goto no_block; 174 goto no_block;
177 175
178 while (--depth) { 176 while (--depth) {
179 __fs64 *ptr; 177 __fs64 *ptr;
180 struct buffer_head *bh; 178 struct buffer_head *bh;
181 unsigned n = *p++; 179 unsigned n = *p++;
182 180
183 bh = sb_bread(sb, uspi->s_sbba 181 bh = sb_bread(sb, uspi->s_sbbase +
184 fs64_to_cpu( 182 fs64_to_cpu(sb, q->key64) + (n>>shift));
185 if (!bh) 183 if (!bh)
186 goto no_block; 184 goto no_block;
187 ptr = (__fs64 *)bh->b_data + ( 185 ptr = (__fs64 *)bh->b_data + (n & mask);
188 if (!grow_chain64(ufsi, bh, pt 186 if (!grow_chain64(ufsi, bh, ptr, chain, ++q))
189 goto changed; 187 goto changed;
190 if (!q->key64) 188 if (!q->key64)
191 goto no_block; 189 goto no_block;
192 } 190 }
193 res = fs64_to_cpu(sb, q->key64); 191 res = fs64_to_cpu(sb, q->key64);
194 found: 192 found:
195 res += uspi->s_sbbase; 193 res += uspi->s_sbbase;
196 no_block: 194 no_block:
197 while (q > chain) { 195 while (q > chain) {
198 brelse(q->bh); 196 brelse(q->bh);
199 q--; 197 q--;
200 } 198 }
201 return res; 199 return res;
202 200
203 changed: 201 changed:
204 while (q > chain) { 202 while (q > chain) {
205 brelse(q->bh); 203 brelse(q->bh);
206 q--; 204 q--;
207 } 205 }
208 goto again; 206 goto again;
209 } 207 }
210 208
211 /* 209 /*
212 * Unpacking tails: we have a file with partia 210 * Unpacking tails: we have a file with partial final block and
213 * we had been asked to extend it. If the fra 211 * we had been asked to extend it. If the fragment being written
214 * is within the same block, we need to extend 212 * is within the same block, we need to extend the tail just to cover
215 * that fragment. Otherwise the tail is exten 213 * that fragment. Otherwise the tail is extended to full block.
216 * 214 *
217 * Note that we might need to create a _new_ t 215 * Note that we might need to create a _new_ tail, but that will
218 * be handled elsewhere; this is strictly for 216 * be handled elsewhere; this is strictly for resizing old
219 * ones. 217 * ones.
220 */ 218 */
221 static bool 219 static bool
222 ufs_extend_tail(struct inode *inode, u64 write 220 ufs_extend_tail(struct inode *inode, u64 writes_to,
223 int *err, struct page *locke 221 int *err, struct page *locked_page)
224 { 222 {
225 struct ufs_inode_info *ufsi = UFS_I(in 223 struct ufs_inode_info *ufsi = UFS_I(inode);
226 struct super_block *sb = inode->i_sb; 224 struct super_block *sb = inode->i_sb;
227 struct ufs_sb_private_info *uspi = UFS 225 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
228 unsigned lastfrag = ufsi->i_lastfrag; 226 unsigned lastfrag = ufsi->i_lastfrag; /* it's a short file, so unsigned is enough */
229 unsigned block = ufs_fragstoblks(lastf 227 unsigned block = ufs_fragstoblks(lastfrag);
230 unsigned new_size; 228 unsigned new_size;
231 void *p; 229 void *p;
232 u64 tmp; 230 u64 tmp;
233 231
234 if (writes_to < (lastfrag | uspi->s_fp 232 if (writes_to < (lastfrag | uspi->s_fpbmask))
235 new_size = (writes_to & uspi-> 233 new_size = (writes_to & uspi->s_fpbmask) + 1;
236 else 234 else
237 new_size = uspi->s_fpb; 235 new_size = uspi->s_fpb;
238 236
239 p = ufs_get_direct_data_ptr(uspi, ufsi 237 p = ufs_get_direct_data_ptr(uspi, ufsi, block);
240 tmp = ufs_new_fragments(inode, p, last 238 tmp = ufs_new_fragments(inode, p, lastfrag, ufs_data_ptr_to_cpu(sb, p),
241 new_size - (la 239 new_size - (lastfrag & uspi->s_fpbmask), err,
242 locked_page); 240 locked_page);
243 return tmp != 0; 241 return tmp != 0;
244 } 242 }
245 243
246 /** 244 /**
247 * ufs_inode_getfrag() - allocate new fragment 245 * ufs_inode_getfrag() - allocate new fragment(s)
248 * @inode: pointer to inode 246 * @inode: pointer to inode
249 * @index: number of block pointer within the 247 * @index: number of block pointer within the inode's array.
250 * @new_fragment: number of new allocated frag 248 * @new_fragment: number of new allocated fragment(s)
251 * @err: we set it if something wrong 249 * @err: we set it if something wrong
252 * @new: we set it if we allocate new block 250 * @new: we set it if we allocate new block
253 * @locked_page: for ufs_new_fragments() 251 * @locked_page: for ufs_new_fragments()
254 */ 252 */
255 static u64 253 static u64
256 ufs_inode_getfrag(struct inode *inode, unsigne 254 ufs_inode_getfrag(struct inode *inode, unsigned index,
257 sector_t new_fragment, int * 255 sector_t new_fragment, int *err,
258 int *new, struct page *locke 256 int *new, struct page *locked_page)
259 { 257 {
260 struct ufs_inode_info *ufsi = UFS_I(in 258 struct ufs_inode_info *ufsi = UFS_I(inode);
261 struct super_block *sb = inode->i_sb; 259 struct super_block *sb = inode->i_sb;
262 struct ufs_sb_private_info *uspi = UFS 260 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
263 u64 tmp, goal, lastfrag; 261 u64 tmp, goal, lastfrag;
264 unsigned nfrags = uspi->s_fpb; 262 unsigned nfrags = uspi->s_fpb;
265 void *p; 263 void *p;
266 264
267 /* TODO : to be done for write support 265 /* TODO : to be done for write support
268 if ( (flags & UFS_TYPE_MASK) == UFS_TY 266 if ( (flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
269 goto ufs2; 267 goto ufs2;
270 */ 268 */
271 269
272 p = ufs_get_direct_data_ptr(uspi, ufsi 270 p = ufs_get_direct_data_ptr(uspi, ufsi, index);
273 tmp = ufs_data_ptr_to_cpu(sb, p); 271 tmp = ufs_data_ptr_to_cpu(sb, p);
274 if (tmp) 272 if (tmp)
275 goto out; 273 goto out;
276 274
277 lastfrag = ufsi->i_lastfrag; 275 lastfrag = ufsi->i_lastfrag;
278 276
279 /* will that be a new tail? */ 277 /* will that be a new tail? */
280 if (new_fragment < UFS_NDIR_FRAGMENT & 278 if (new_fragment < UFS_NDIR_FRAGMENT && new_fragment >= lastfrag)
281 nfrags = (new_fragment & uspi- 279 nfrags = (new_fragment & uspi->s_fpbmask) + 1;
282 280
283 goal = 0; 281 goal = 0;
284 if (index) { 282 if (index) {
285 goal = ufs_data_ptr_to_cpu(sb, 283 goal = ufs_data_ptr_to_cpu(sb,
286 ufs_get_direc 284 ufs_get_direct_data_ptr(uspi, ufsi, index - 1));
287 if (goal) 285 if (goal)
288 goal += uspi->s_fpb; 286 goal += uspi->s_fpb;
289 } 287 }
290 tmp = ufs_new_fragments(inode, p, ufs_ 288 tmp = ufs_new_fragments(inode, p, ufs_blknum(new_fragment),
291 goal, nfrags, 289 goal, nfrags, err, locked_page);
292 290
293 if (!tmp) { 291 if (!tmp) {
294 *err = -ENOSPC; 292 *err = -ENOSPC;
295 return 0; 293 return 0;
296 } 294 }
297 295
298 if (new) 296 if (new)
299 *new = 1; 297 *new = 1;
300 inode_set_ctime_current(inode); !! 298 inode->i_ctime = current_time(inode);
301 if (IS_SYNC(inode)) 299 if (IS_SYNC(inode))
302 ufs_sync_inode (inode); 300 ufs_sync_inode (inode);
303 mark_inode_dirty(inode); 301 mark_inode_dirty(inode);
304 out: 302 out:
305 return tmp + uspi->s_sbbase; 303 return tmp + uspi->s_sbbase;
306 304
307 /* This part : To be implemented .... 305 /* This part : To be implemented ....
308 Required only for writing, not require 306 Required only for writing, not required for READ-ONLY.
309 ufs2: 307 ufs2:
310 308
311 u2_block = ufs_fragstoblks(fragment); 309 u2_block = ufs_fragstoblks(fragment);
312 u2_blockoff = ufs_fragnum(fragment); 310 u2_blockoff = ufs_fragnum(fragment);
313 p = ufsi->i_u1.u2_i_data + block; 311 p = ufsi->i_u1.u2_i_data + block;
314 goal = 0; 312 goal = 0;
315 313
316 repeat2: 314 repeat2:
317 tmp = fs32_to_cpu(sb, *p); 315 tmp = fs32_to_cpu(sb, *p);
318 lastfrag = ufsi->i_lastfrag; 316 lastfrag = ufsi->i_lastfrag;
319 317
320 */ 318 */
321 } 319 }
322 320
323 /** 321 /**
324 * ufs_inode_getblock() - allocate new block 322 * ufs_inode_getblock() - allocate new block
325 * @inode: pointer to inode 323 * @inode: pointer to inode
326 * @ind_block: block number of the indirect bl 324 * @ind_block: block number of the indirect block
327 * @index: number of pointer within the indire 325 * @index: number of pointer within the indirect block
328 * @new_fragment: number of new allocated frag 326 * @new_fragment: number of new allocated fragment
329 * (block will hold this fragment and also us 327 * (block will hold this fragment and also uspi->s_fpb-1)
330 * @err: see ufs_inode_getfrag() 328 * @err: see ufs_inode_getfrag()
331 * @new: see ufs_inode_getfrag() 329 * @new: see ufs_inode_getfrag()
332 * @locked_page: see ufs_inode_getfrag() 330 * @locked_page: see ufs_inode_getfrag()
333 */ 331 */
334 static u64 332 static u64
335 ufs_inode_getblock(struct inode *inode, u64 in 333 ufs_inode_getblock(struct inode *inode, u64 ind_block,
336 unsigned index, sector_t new 334 unsigned index, sector_t new_fragment, int *err,
337 int *new, struct page *locke 335 int *new, struct page *locked_page)
338 { 336 {
339 struct super_block *sb = inode->i_sb; 337 struct super_block *sb = inode->i_sb;
340 struct ufs_sb_private_info *uspi = UFS 338 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
341 int shift = uspi->s_apbshift - uspi->s 339 int shift = uspi->s_apbshift - uspi->s_fpbshift;
342 u64 tmp = 0, goal; 340 u64 tmp = 0, goal;
343 struct buffer_head *bh; 341 struct buffer_head *bh;
344 void *p; 342 void *p;
345 343
346 if (!ind_block) 344 if (!ind_block)
347 return 0; 345 return 0;
348 346
349 bh = sb_bread(sb, ind_block + (index > 347 bh = sb_bread(sb, ind_block + (index >> shift));
350 if (unlikely(!bh)) { 348 if (unlikely(!bh)) {
351 *err = -EIO; 349 *err = -EIO;
352 return 0; 350 return 0;
353 } 351 }
354 352
355 index &= uspi->s_apbmask >> uspi->s_fp 353 index &= uspi->s_apbmask >> uspi->s_fpbshift;
356 if (uspi->fs_magic == UFS2_MAGIC) 354 if (uspi->fs_magic == UFS2_MAGIC)
357 p = (__fs64 *)bh->b_data + ind 355 p = (__fs64 *)bh->b_data + index;
358 else 356 else
359 p = (__fs32 *)bh->b_data + ind 357 p = (__fs32 *)bh->b_data + index;
360 358
361 tmp = ufs_data_ptr_to_cpu(sb, p); 359 tmp = ufs_data_ptr_to_cpu(sb, p);
362 if (tmp) 360 if (tmp)
363 goto out; 361 goto out;
364 362
365 if (index && (uspi->fs_magic == UFS2_M 363 if (index && (uspi->fs_magic == UFS2_MAGIC ?
366 (tmp = fs64_to_cpu(sb, ( 364 (tmp = fs64_to_cpu(sb, ((__fs64 *)bh->b_data)[index-1])) :
367 (tmp = fs32_to_cpu(sb, ( 365 (tmp = fs32_to_cpu(sb, ((__fs32 *)bh->b_data)[index-1]))))
368 goal = tmp + uspi->s_fpb; 366 goal = tmp + uspi->s_fpb;
369 else 367 else
370 goal = bh->b_blocknr + uspi->s 368 goal = bh->b_blocknr + uspi->s_fpb;
371 tmp = ufs_new_fragments(inode, p, ufs_ 369 tmp = ufs_new_fragments(inode, p, ufs_blknum(new_fragment), goal,
372 uspi->s_fpb, e 370 uspi->s_fpb, err, locked_page);
373 if (!tmp) 371 if (!tmp)
374 goto out; 372 goto out;
375 373
376 if (new) 374 if (new)
377 *new = 1; 375 *new = 1;
378 376
379 mark_buffer_dirty(bh); 377 mark_buffer_dirty(bh);
380 if (IS_SYNC(inode)) 378 if (IS_SYNC(inode))
381 sync_dirty_buffer(bh); 379 sync_dirty_buffer(bh);
382 inode_set_ctime_current(inode); !! 380 inode->i_ctime = current_time(inode);
383 mark_inode_dirty(inode); 381 mark_inode_dirty(inode);
384 out: 382 out:
385 brelse (bh); 383 brelse (bh);
386 UFSD("EXIT\n"); 384 UFSD("EXIT\n");
387 if (tmp) 385 if (tmp)
388 tmp += uspi->s_sbbase; 386 tmp += uspi->s_sbbase;
389 return tmp; 387 return tmp;
390 } 388 }
391 389
392 /** 390 /**
393 * ufs_getfrag_block() - `get_block_t' functio 391 * ufs_getfrag_block() - `get_block_t' function, interface between UFS and
394 * read_folio, writepages and so on !! 392 * readpage, writepage and so on
395 */ 393 */
396 394
397 static int ufs_getfrag_block(struct inode *ino 395 static int ufs_getfrag_block(struct inode *inode, sector_t fragment, struct buffer_head *bh_result, int create)
398 { 396 {
399 struct super_block *sb = inode->i_sb; 397 struct super_block *sb = inode->i_sb;
400 struct ufs_sb_private_info *uspi = UFS 398 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
401 int err = 0, new = 0; 399 int err = 0, new = 0;
402 unsigned offsets[4]; 400 unsigned offsets[4];
403 int depth = ufs_block_to_path(inode, f 401 int depth = ufs_block_to_path(inode, fragment >> uspi->s_fpbshift, offsets);
404 u64 phys64 = 0; 402 u64 phys64 = 0;
405 unsigned frag = fragment & uspi->s_fpb 403 unsigned frag = fragment & uspi->s_fpbmask;
406 404
407 phys64 = ufs_frag_map(inode, offsets, 405 phys64 = ufs_frag_map(inode, offsets, depth);
408 if (!create) 406 if (!create)
409 goto done; 407 goto done;
410 408
411 if (phys64) { 409 if (phys64) {
412 if (fragment >= UFS_NDIR_FRAGM 410 if (fragment >= UFS_NDIR_FRAGMENT)
413 goto done; 411 goto done;
414 read_seqlock_excl(&UFS_I(inode 412 read_seqlock_excl(&UFS_I(inode)->meta_lock);
415 if (fragment < UFS_I(inode)->i 413 if (fragment < UFS_I(inode)->i_lastfrag) {
416 read_sequnlock_excl(&U 414 read_sequnlock_excl(&UFS_I(inode)->meta_lock);
417 goto done; 415 goto done;
418 } 416 }
419 read_sequnlock_excl(&UFS_I(ino 417 read_sequnlock_excl(&UFS_I(inode)->meta_lock);
420 } 418 }
421 /* This code entered only while writin 419 /* This code entered only while writing ....? */
422 420
423 mutex_lock(&UFS_I(inode)->truncate_mut 421 mutex_lock(&UFS_I(inode)->truncate_mutex);
424 422
425 UFSD("ENTER, ino %lu, fragment %llu\n" 423 UFSD("ENTER, ino %lu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment);
426 if (unlikely(!depth)) { 424 if (unlikely(!depth)) {
427 ufs_warning(sb, "ufs_get_block 425 ufs_warning(sb, "ufs_get_block", "block > big");
428 err = -EIO; 426 err = -EIO;
429 goto out; 427 goto out;
430 } 428 }
431 429
432 if (UFS_I(inode)->i_lastfrag < UFS_NDI 430 if (UFS_I(inode)->i_lastfrag < UFS_NDIR_FRAGMENT) {
433 unsigned lastfrag = UFS_I(inod 431 unsigned lastfrag = UFS_I(inode)->i_lastfrag;
434 unsigned tailfrags = lastfrag 432 unsigned tailfrags = lastfrag & uspi->s_fpbmask;
435 if (tailfrags && fragment >= l 433 if (tailfrags && fragment >= lastfrag) {
436 if (!ufs_extend_tail(i 434 if (!ufs_extend_tail(inode, fragment,
437 & 435 &err, bh_result->b_page))
438 goto out; 436 goto out;
439 } 437 }
440 } 438 }
441 439
442 if (depth == 1) { 440 if (depth == 1) {
443 phys64 = ufs_inode_getfrag(ino 441 phys64 = ufs_inode_getfrag(inode, offsets[0], fragment,
444 &er 442 &err, &new, bh_result->b_page);
445 } else { 443 } else {
446 int i; 444 int i;
447 phys64 = ufs_inode_getfrag(ino 445 phys64 = ufs_inode_getfrag(inode, offsets[0], fragment,
448 &er 446 &err, NULL, NULL);
449 for (i = 1; i < depth - 1; i++ 447 for (i = 1; i < depth - 1; i++)
450 phys64 = ufs_inode_get 448 phys64 = ufs_inode_getblock(inode, phys64, offsets[i],
451 449 fragment, &err, NULL, NULL);
452 phys64 = ufs_inode_getblock(in 450 phys64 = ufs_inode_getblock(inode, phys64, offsets[depth - 1],
453 fragme 451 fragment, &err, &new, bh_result->b_page);
454 } 452 }
455 out: 453 out:
456 if (phys64) { 454 if (phys64) {
457 phys64 += frag; 455 phys64 += frag;
458 map_bh(bh_result, sb, phys64); 456 map_bh(bh_result, sb, phys64);
459 if (new) 457 if (new)
460 set_buffer_new(bh_resu 458 set_buffer_new(bh_result);
461 } 459 }
462 mutex_unlock(&UFS_I(inode)->truncate_m 460 mutex_unlock(&UFS_I(inode)->truncate_mutex);
463 return err; 461 return err;
464 462
465 done: 463 done:
466 if (phys64) 464 if (phys64)
467 map_bh(bh_result, sb, phys64 + 465 map_bh(bh_result, sb, phys64 + frag);
468 return 0; 466 return 0;
469 } 467 }
470 468
471 static int ufs_writepages(struct address_space !! 469 static int ufs_writepage(struct page *page, struct writeback_control *wbc)
472 struct writeback_control *wbc) <<
473 { 470 {
474 return mpage_writepages(mapping, wbc, !! 471 return block_write_full_page(page,ufs_getfrag_block,wbc);
475 } 472 }
476 473
477 static int ufs_read_folio(struct file *file, s !! 474 static int ufs_readpage(struct file *file, struct page *page)
478 { 475 {
479 return block_read_full_folio(folio, uf !! 476 return block_read_full_page(page,ufs_getfrag_block);
480 } 477 }
481 478
482 int ufs_prepare_chunk(struct page *page, loff_ 479 int ufs_prepare_chunk(struct page *page, loff_t pos, unsigned len)
483 { 480 {
484 return __block_write_begin(page, pos, 481 return __block_write_begin(page, pos, len, ufs_getfrag_block);
485 } 482 }
486 483
487 static void ufs_truncate_blocks(struct inode * 484 static void ufs_truncate_blocks(struct inode *);
488 485
489 static void ufs_write_failed(struct address_sp 486 static void ufs_write_failed(struct address_space *mapping, loff_t to)
490 { 487 {
491 struct inode *inode = mapping->host; 488 struct inode *inode = mapping->host;
492 489
493 if (to > inode->i_size) { 490 if (to > inode->i_size) {
494 truncate_pagecache(inode, inod 491 truncate_pagecache(inode, inode->i_size);
495 ufs_truncate_blocks(inode); 492 ufs_truncate_blocks(inode);
496 } 493 }
497 } 494 }
498 495
499 static int ufs_write_begin(struct file *file, 496 static int ufs_write_begin(struct file *file, struct address_space *mapping,
500 loff_t pos, unsigned l !! 497 loff_t pos, unsigned len, unsigned flags,
501 struct page **pagep, v 498 struct page **pagep, void **fsdata)
502 { 499 {
503 int ret; 500 int ret;
504 501
505 ret = block_write_begin(mapping, pos, !! 502 ret = block_write_begin(mapping, pos, len, flags, pagep,
>> 503 ufs_getfrag_block);
506 if (unlikely(ret)) 504 if (unlikely(ret))
507 ufs_write_failed(mapping, pos 505 ufs_write_failed(mapping, pos + len);
508 506
509 return ret; 507 return ret;
510 } 508 }
511 509
512 static int ufs_write_end(struct file *file, st 510 static int ufs_write_end(struct file *file, struct address_space *mapping,
513 loff_t pos, unsigned l 511 loff_t pos, unsigned len, unsigned copied,
514 struct page *page, voi 512 struct page *page, void *fsdata)
515 { 513 {
516 int ret; 514 int ret;
517 515
518 ret = generic_write_end(file, mapping, 516 ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
519 if (ret < len) 517 if (ret < len)
520 ufs_write_failed(mapping, pos 518 ufs_write_failed(mapping, pos + len);
521 return ret; 519 return ret;
522 } 520 }
523 521
524 static sector_t ufs_bmap(struct address_space 522 static sector_t ufs_bmap(struct address_space *mapping, sector_t block)
525 { 523 {
526 return generic_block_bmap(mapping,bloc 524 return generic_block_bmap(mapping,block,ufs_getfrag_block);
527 } 525 }
528 526
529 const struct address_space_operations ufs_aops 527 const struct address_space_operations ufs_aops = {
530 .dirty_folio = block_dirty_folio, !! 528 .readpage = ufs_readpage,
531 .invalidate_folio = block_invalidate_f !! 529 .writepage = ufs_writepage,
532 .read_folio = ufs_read_folio, <<
533 .writepages = ufs_writepages, <<
534 .write_begin = ufs_write_begin, 530 .write_begin = ufs_write_begin,
535 .write_end = ufs_write_end, 531 .write_end = ufs_write_end,
536 .migrate_folio = buffer_migrate_folio, <<
537 .bmap = ufs_bmap 532 .bmap = ufs_bmap
538 }; 533 };
539 534
540 static void ufs_set_inode_ops(struct inode *in 535 static void ufs_set_inode_ops(struct inode *inode)
541 { 536 {
542 if (S_ISREG(inode->i_mode)) { 537 if (S_ISREG(inode->i_mode)) {
543 inode->i_op = &ufs_file_inode_ 538 inode->i_op = &ufs_file_inode_operations;
544 inode->i_fop = &ufs_file_opera 539 inode->i_fop = &ufs_file_operations;
545 inode->i_mapping->a_ops = &ufs 540 inode->i_mapping->a_ops = &ufs_aops;
546 } else if (S_ISDIR(inode->i_mode)) { 541 } else if (S_ISDIR(inode->i_mode)) {
547 inode->i_op = &ufs_dir_inode_o 542 inode->i_op = &ufs_dir_inode_operations;
548 inode->i_fop = &ufs_dir_operat 543 inode->i_fop = &ufs_dir_operations;
549 inode->i_mapping->a_ops = &ufs 544 inode->i_mapping->a_ops = &ufs_aops;
550 } else if (S_ISLNK(inode->i_mode)) { 545 } else if (S_ISLNK(inode->i_mode)) {
551 if (!inode->i_blocks) { 546 if (!inode->i_blocks) {
552 inode->i_link = (char 547 inode->i_link = (char *)UFS_I(inode)->i_u1.i_symlink;
553 inode->i_op = &simple_ 548 inode->i_op = &simple_symlink_inode_operations;
554 } else { 549 } else {
555 inode->i_mapping->a_op 550 inode->i_mapping->a_ops = &ufs_aops;
556 inode->i_op = &page_sy 551 inode->i_op = &page_symlink_inode_operations;
557 inode_nohighmem(inode) 552 inode_nohighmem(inode);
558 } 553 }
559 } else 554 } else
560 init_special_inode(inode, inod 555 init_special_inode(inode, inode->i_mode,
561 ufs_get_ino 556 ufs_get_inode_dev(inode->i_sb, UFS_I(inode)));
562 } 557 }
563 558
564 static int ufs1_read_inode(struct inode *inode 559 static int ufs1_read_inode(struct inode *inode, struct ufs_inode *ufs_inode)
565 { 560 {
566 struct ufs_inode_info *ufsi = UFS_I(in 561 struct ufs_inode_info *ufsi = UFS_I(inode);
567 struct super_block *sb = inode->i_sb; 562 struct super_block *sb = inode->i_sb;
568 umode_t mode; 563 umode_t mode;
569 564
570 /* 565 /*
571 * Copy data to the in-core inode. 566 * Copy data to the in-core inode.
572 */ 567 */
573 inode->i_mode = mode = fs16_to_cpu(sb, 568 inode->i_mode = mode = fs16_to_cpu(sb, ufs_inode->ui_mode);
574 set_nlink(inode, fs16_to_cpu(sb, ufs_i 569 set_nlink(inode, fs16_to_cpu(sb, ufs_inode->ui_nlink));
575 if (inode->i_nlink == 0) 570 if (inode->i_nlink == 0)
576 return -ESTALE; 571 return -ESTALE;
577 572
578 /* 573 /*
579 * Linux now has 32-bit uid and gid, s 574 * Linux now has 32-bit uid and gid, so we can support EFT.
580 */ 575 */
581 i_uid_write(inode, ufs_get_inode_uid(s 576 i_uid_write(inode, ufs_get_inode_uid(sb, ufs_inode));
582 i_gid_write(inode, ufs_get_inode_gid(s 577 i_gid_write(inode, ufs_get_inode_gid(sb, ufs_inode));
583 578
584 inode->i_size = fs64_to_cpu(sb, ufs_in 579 inode->i_size = fs64_to_cpu(sb, ufs_inode->ui_size);
585 inode_set_atime(inode, !! 580 inode->i_atime.tv_sec = (signed)fs32_to_cpu(sb, ufs_inode->ui_atime.tv_sec);
586 (signed)fs32_to_cpu(sb !! 581 inode->i_ctime.tv_sec = (signed)fs32_to_cpu(sb, ufs_inode->ui_ctime.tv_sec);
587 0); !! 582 inode->i_mtime.tv_sec = (signed)fs32_to_cpu(sb, ufs_inode->ui_mtime.tv_sec);
588 inode_set_ctime(inode, !! 583 inode->i_mtime.tv_nsec = 0;
589 (signed)fs32_to_cpu(sb !! 584 inode->i_atime.tv_nsec = 0;
590 0); !! 585 inode->i_ctime.tv_nsec = 0;
591 inode_set_mtime(inode, <<
592 (signed)fs32_to_cpu(sb <<
593 0); <<
594 inode->i_blocks = fs32_to_cpu(sb, ufs_ 586 inode->i_blocks = fs32_to_cpu(sb, ufs_inode->ui_blocks);
595 inode->i_generation = fs32_to_cpu(sb, 587 inode->i_generation = fs32_to_cpu(sb, ufs_inode->ui_gen);
596 ufsi->i_flags = fs32_to_cpu(sb, ufs_in 588 ufsi->i_flags = fs32_to_cpu(sb, ufs_inode->ui_flags);
597 ufsi->i_shadow = fs32_to_cpu(sb, ufs_i 589 ufsi->i_shadow = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_shadow);
598 ufsi->i_oeftflag = fs32_to_cpu(sb, ufs 590 ufsi->i_oeftflag = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_oeftflag);
599 591
600 592
601 if (S_ISCHR(mode) || S_ISBLK(mode) || 593 if (S_ISCHR(mode) || S_ISBLK(mode) || inode->i_blocks) {
602 memcpy(ufsi->i_u1.i_data, &ufs 594 memcpy(ufsi->i_u1.i_data, &ufs_inode->ui_u2.ui_addr,
603 sizeof(ufs_inode->ui_u2 595 sizeof(ufs_inode->ui_u2.ui_addr));
604 } else { 596 } else {
605 memcpy(ufsi->i_u1.i_symlink, u 597 memcpy(ufsi->i_u1.i_symlink, ufs_inode->ui_u2.ui_symlink,
606 sizeof(ufs_inode->ui_u2 598 sizeof(ufs_inode->ui_u2.ui_symlink) - 1);
607 ufsi->i_u1.i_symlink[sizeof(uf 599 ufsi->i_u1.i_symlink[sizeof(ufs_inode->ui_u2.ui_symlink) - 1] = 0;
608 } 600 }
609 return 0; 601 return 0;
610 } 602 }
611 603
612 static int ufs2_read_inode(struct inode *inode 604 static int ufs2_read_inode(struct inode *inode, struct ufs2_inode *ufs2_inode)
613 { 605 {
614 struct ufs_inode_info *ufsi = UFS_I(in 606 struct ufs_inode_info *ufsi = UFS_I(inode);
615 struct super_block *sb = inode->i_sb; 607 struct super_block *sb = inode->i_sb;
616 umode_t mode; 608 umode_t mode;
617 609
618 UFSD("Reading ufs2 inode, ino %lu\n", 610 UFSD("Reading ufs2 inode, ino %lu\n", inode->i_ino);
619 /* 611 /*
620 * Copy data to the in-core inode. 612 * Copy data to the in-core inode.
621 */ 613 */
622 inode->i_mode = mode = fs16_to_cpu(sb, 614 inode->i_mode = mode = fs16_to_cpu(sb, ufs2_inode->ui_mode);
623 set_nlink(inode, fs16_to_cpu(sb, ufs2_ 615 set_nlink(inode, fs16_to_cpu(sb, ufs2_inode->ui_nlink));
624 if (inode->i_nlink == 0) 616 if (inode->i_nlink == 0)
625 return -ESTALE; 617 return -ESTALE;
626 618
627 /* 619 /*
628 * Linux now has 32-bit uid and gid, s 620 * Linux now has 32-bit uid and gid, so we can support EFT.
629 */ 621 */
630 i_uid_write(inode, fs32_to_cpu(sb, ufs 622 i_uid_write(inode, fs32_to_cpu(sb, ufs2_inode->ui_uid));
631 i_gid_write(inode, fs32_to_cpu(sb, ufs 623 i_gid_write(inode, fs32_to_cpu(sb, ufs2_inode->ui_gid));
632 624
633 inode->i_size = fs64_to_cpu(sb, ufs2_i 625 inode->i_size = fs64_to_cpu(sb, ufs2_inode->ui_size);
634 inode_set_atime(inode, fs64_to_cpu(sb, !! 626 inode->i_atime.tv_sec = fs64_to_cpu(sb, ufs2_inode->ui_atime);
635 fs32_to_cpu(sb, ufs2_i !! 627 inode->i_ctime.tv_sec = fs64_to_cpu(sb, ufs2_inode->ui_ctime);
636 inode_set_ctime(inode, fs64_to_cpu(sb, !! 628 inode->i_mtime.tv_sec = fs64_to_cpu(sb, ufs2_inode->ui_mtime);
637 fs32_to_cpu(sb, ufs2_i !! 629 inode->i_atime.tv_nsec = fs32_to_cpu(sb, ufs2_inode->ui_atimensec);
638 inode_set_mtime(inode, fs64_to_cpu(sb, !! 630 inode->i_ctime.tv_nsec = fs32_to_cpu(sb, ufs2_inode->ui_ctimensec);
639 fs32_to_cpu(sb, ufs2_i !! 631 inode->i_mtime.tv_nsec = fs32_to_cpu(sb, ufs2_inode->ui_mtimensec);
640 inode->i_blocks = fs64_to_cpu(sb, ufs2 632 inode->i_blocks = fs64_to_cpu(sb, ufs2_inode->ui_blocks);
641 inode->i_generation = fs32_to_cpu(sb, 633 inode->i_generation = fs32_to_cpu(sb, ufs2_inode->ui_gen);
642 ufsi->i_flags = fs32_to_cpu(sb, ufs2_i 634 ufsi->i_flags = fs32_to_cpu(sb, ufs2_inode->ui_flags);
643 /* 635 /*
644 ufsi->i_shadow = fs32_to_cpu(sb, ufs_i 636 ufsi->i_shadow = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_shadow);
645 ufsi->i_oeftflag = fs32_to_cpu(sb, ufs 637 ufsi->i_oeftflag = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_oeftflag);
646 */ 638 */
647 639
648 if (S_ISCHR(mode) || S_ISBLK(mode) || 640 if (S_ISCHR(mode) || S_ISBLK(mode) || inode->i_blocks) {
649 memcpy(ufsi->i_u1.u2_i_data, & 641 memcpy(ufsi->i_u1.u2_i_data, &ufs2_inode->ui_u2.ui_addr,
650 sizeof(ufs2_inode->ui_u 642 sizeof(ufs2_inode->ui_u2.ui_addr));
651 } else { 643 } else {
652 memcpy(ufsi->i_u1.i_symlink, u 644 memcpy(ufsi->i_u1.i_symlink, ufs2_inode->ui_u2.ui_symlink,
653 sizeof(ufs2_inode->ui_u 645 sizeof(ufs2_inode->ui_u2.ui_symlink) - 1);
654 ufsi->i_u1.i_symlink[sizeof(uf 646 ufsi->i_u1.i_symlink[sizeof(ufs2_inode->ui_u2.ui_symlink) - 1] = 0;
655 } 647 }
656 return 0; 648 return 0;
657 } 649 }
658 650
659 struct inode *ufs_iget(struct super_block *sb, 651 struct inode *ufs_iget(struct super_block *sb, unsigned long ino)
660 { 652 {
661 struct ufs_inode_info *ufsi; 653 struct ufs_inode_info *ufsi;
662 struct ufs_sb_private_info *uspi = UFS 654 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
663 struct buffer_head * bh; 655 struct buffer_head * bh;
664 struct inode *inode; 656 struct inode *inode;
665 int err = -EIO; 657 int err = -EIO;
666 658
667 UFSD("ENTER, ino %lu\n", ino); 659 UFSD("ENTER, ino %lu\n", ino);
668 660
669 if (ino < UFS_ROOTINO || ino > (uspi-> 661 if (ino < UFS_ROOTINO || ino > (uspi->s_ncg * uspi->s_ipg)) {
670 ufs_warning(sb, "ufs_read_inod 662 ufs_warning(sb, "ufs_read_inode", "bad inode number (%lu)\n",
671 ino); 663 ino);
672 return ERR_PTR(-EIO); 664 return ERR_PTR(-EIO);
673 } 665 }
674 666
675 inode = iget_locked(sb, ino); 667 inode = iget_locked(sb, ino);
676 if (!inode) 668 if (!inode)
677 return ERR_PTR(-ENOMEM); 669 return ERR_PTR(-ENOMEM);
678 if (!(inode->i_state & I_NEW)) 670 if (!(inode->i_state & I_NEW))
679 return inode; 671 return inode;
680 672
681 ufsi = UFS_I(inode); 673 ufsi = UFS_I(inode);
682 674
683 bh = sb_bread(sb, uspi->s_sbbase + ufs 675 bh = sb_bread(sb, uspi->s_sbbase + ufs_inotofsba(inode->i_ino));
684 if (!bh) { 676 if (!bh) {
685 ufs_warning(sb, "ufs_read_inod 677 ufs_warning(sb, "ufs_read_inode", "unable to read inode %lu\n",
686 inode->i_ino); 678 inode->i_ino);
687 goto bad_inode; 679 goto bad_inode;
688 } 680 }
689 if ((UFS_SB(sb)->s_flags & UFS_TYPE_MA 681 if ((UFS_SB(sb)->s_flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
690 struct ufs2_inode *ufs2_inode 682 struct ufs2_inode *ufs2_inode = (struct ufs2_inode *)bh->b_data;
691 683
692 err = ufs2_read_inode(inode, 684 err = ufs2_read_inode(inode,
693 ufs2_ino 685 ufs2_inode + ufs_inotofsbo(inode->i_ino));
694 } else { 686 } else {
695 struct ufs_inode *ufs_inode = 687 struct ufs_inode *ufs_inode = (struct ufs_inode *)bh->b_data;
696 688
697 err = ufs1_read_inode(inode, 689 err = ufs1_read_inode(inode,
698 ufs_inod 690 ufs_inode + ufs_inotofsbo(inode->i_ino));
699 } 691 }
700 brelse(bh); 692 brelse(bh);
701 if (err) 693 if (err)
702 goto bad_inode; 694 goto bad_inode;
703 695
704 inode_inc_iversion(inode); !! 696 inode->i_version++;
705 ufsi->i_lastfrag = 697 ufsi->i_lastfrag =
706 (inode->i_size + uspi->s_fsize 698 (inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift;
707 ufsi->i_dir_start_lookup = 0; 699 ufsi->i_dir_start_lookup = 0;
708 ufsi->i_osync = 0; 700 ufsi->i_osync = 0;
709 701
710 ufs_set_inode_ops(inode); 702 ufs_set_inode_ops(inode);
711 703
712 UFSD("EXIT\n"); 704 UFSD("EXIT\n");
713 unlock_new_inode(inode); 705 unlock_new_inode(inode);
714 return inode; 706 return inode;
715 707
716 bad_inode: 708 bad_inode:
717 iget_failed(inode); 709 iget_failed(inode);
718 return ERR_PTR(err); 710 return ERR_PTR(err);
719 } 711 }
720 712
721 static void ufs1_update_inode(struct inode *in 713 static void ufs1_update_inode(struct inode *inode, struct ufs_inode *ufs_inode)
722 { 714 {
723 struct super_block *sb = inode->i_sb; 715 struct super_block *sb = inode->i_sb;
724 struct ufs_inode_info *ufsi = UFS_I(in 716 struct ufs_inode_info *ufsi = UFS_I(inode);
725 717
726 ufs_inode->ui_mode = cpu_to_fs16(sb, i 718 ufs_inode->ui_mode = cpu_to_fs16(sb, inode->i_mode);
727 ufs_inode->ui_nlink = cpu_to_fs16(sb, 719 ufs_inode->ui_nlink = cpu_to_fs16(sb, inode->i_nlink);
728 720
729 ufs_set_inode_uid(sb, ufs_inode, i_uid 721 ufs_set_inode_uid(sb, ufs_inode, i_uid_read(inode));
730 ufs_set_inode_gid(sb, ufs_inode, i_gid 722 ufs_set_inode_gid(sb, ufs_inode, i_gid_read(inode));
731 723
732 ufs_inode->ui_size = cpu_to_fs64(sb, i 724 ufs_inode->ui_size = cpu_to_fs64(sb, inode->i_size);
733 ufs_inode->ui_atime.tv_sec = cpu_to_fs !! 725 ufs_inode->ui_atime.tv_sec = cpu_to_fs32(sb, inode->i_atime.tv_sec);
734 <<
735 ufs_inode->ui_atime.tv_usec = 0; 726 ufs_inode->ui_atime.tv_usec = 0;
736 ufs_inode->ui_ctime.tv_sec = cpu_to_fs !! 727 ufs_inode->ui_ctime.tv_sec = cpu_to_fs32(sb, inode->i_ctime.tv_sec);
737 <<
738 ufs_inode->ui_ctime.tv_usec = 0; 728 ufs_inode->ui_ctime.tv_usec = 0;
739 ufs_inode->ui_mtime.tv_sec = cpu_to_fs !! 729 ufs_inode->ui_mtime.tv_sec = cpu_to_fs32(sb, inode->i_mtime.tv_sec);
740 <<
741 ufs_inode->ui_mtime.tv_usec = 0; 730 ufs_inode->ui_mtime.tv_usec = 0;
742 ufs_inode->ui_blocks = cpu_to_fs32(sb, 731 ufs_inode->ui_blocks = cpu_to_fs32(sb, inode->i_blocks);
743 ufs_inode->ui_flags = cpu_to_fs32(sb, 732 ufs_inode->ui_flags = cpu_to_fs32(sb, ufsi->i_flags);
744 ufs_inode->ui_gen = cpu_to_fs32(sb, in 733 ufs_inode->ui_gen = cpu_to_fs32(sb, inode->i_generation);
745 734
746 if ((UFS_SB(sb)->s_flags & UFS_UID_MAS 735 if ((UFS_SB(sb)->s_flags & UFS_UID_MASK) == UFS_UID_EFT) {
747 ufs_inode->ui_u3.ui_sun.ui_sha 736 ufs_inode->ui_u3.ui_sun.ui_shadow = cpu_to_fs32(sb, ufsi->i_shadow);
748 ufs_inode->ui_u3.ui_sun.ui_oef 737 ufs_inode->ui_u3.ui_sun.ui_oeftflag = cpu_to_fs32(sb, ufsi->i_oeftflag);
749 } 738 }
750 739
751 if (S_ISCHR(inode->i_mode) || S_ISBLK( 740 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
752 /* ufs_inode->ui_u2.ui_addr.ui 741 /* ufs_inode->ui_u2.ui_addr.ui_db[0] = cpu_to_fs32(sb, inode->i_rdev); */
753 ufs_inode->ui_u2.ui_addr.ui_db 742 ufs_inode->ui_u2.ui_addr.ui_db[0] = ufsi->i_u1.i_data[0];
754 } else if (inode->i_blocks) { 743 } else if (inode->i_blocks) {
755 memcpy(&ufs_inode->ui_u2.ui_ad 744 memcpy(&ufs_inode->ui_u2.ui_addr, ufsi->i_u1.i_data,
756 sizeof(ufs_inode->ui_u2 745 sizeof(ufs_inode->ui_u2.ui_addr));
757 } 746 }
758 else { 747 else {
759 memcpy(&ufs_inode->ui_u2.ui_sy 748 memcpy(&ufs_inode->ui_u2.ui_symlink, ufsi->i_u1.i_symlink,
760 sizeof(ufs_inode->ui_u2 749 sizeof(ufs_inode->ui_u2.ui_symlink));
761 } 750 }
762 751
763 if (!inode->i_nlink) 752 if (!inode->i_nlink)
764 memset (ufs_inode, 0, sizeof(s 753 memset (ufs_inode, 0, sizeof(struct ufs_inode));
765 } 754 }
766 755
767 static void ufs2_update_inode(struct inode *in 756 static void ufs2_update_inode(struct inode *inode, struct ufs2_inode *ufs_inode)
768 { 757 {
769 struct super_block *sb = inode->i_sb; 758 struct super_block *sb = inode->i_sb;
770 struct ufs_inode_info *ufsi = UFS_I(in 759 struct ufs_inode_info *ufsi = UFS_I(inode);
771 760
772 UFSD("ENTER\n"); 761 UFSD("ENTER\n");
773 ufs_inode->ui_mode = cpu_to_fs16(sb, i 762 ufs_inode->ui_mode = cpu_to_fs16(sb, inode->i_mode);
774 ufs_inode->ui_nlink = cpu_to_fs16(sb, 763 ufs_inode->ui_nlink = cpu_to_fs16(sb, inode->i_nlink);
775 764
776 ufs_inode->ui_uid = cpu_to_fs32(sb, i_ 765 ufs_inode->ui_uid = cpu_to_fs32(sb, i_uid_read(inode));
777 ufs_inode->ui_gid = cpu_to_fs32(sb, i_ 766 ufs_inode->ui_gid = cpu_to_fs32(sb, i_gid_read(inode));
778 767
779 ufs_inode->ui_size = cpu_to_fs64(sb, i 768 ufs_inode->ui_size = cpu_to_fs64(sb, inode->i_size);
780 ufs_inode->ui_atime = cpu_to_fs64(sb, !! 769 ufs_inode->ui_atime = cpu_to_fs64(sb, inode->i_atime.tv_sec);
781 ufs_inode->ui_atimensec = cpu_to_fs32( !! 770 ufs_inode->ui_atimensec = cpu_to_fs32(sb, inode->i_atime.tv_nsec);
782 !! 771 ufs_inode->ui_ctime = cpu_to_fs64(sb, inode->i_ctime.tv_sec);
783 ufs_inode->ui_ctime = cpu_to_fs64(sb, !! 772 ufs_inode->ui_ctimensec = cpu_to_fs32(sb, inode->i_ctime.tv_nsec);
784 ufs_inode->ui_ctimensec = cpu_to_fs32( !! 773 ufs_inode->ui_mtime = cpu_to_fs64(sb, inode->i_mtime.tv_sec);
785 !! 774 ufs_inode->ui_mtimensec = cpu_to_fs32(sb, inode->i_mtime.tv_nsec);
786 ufs_inode->ui_mtime = cpu_to_fs64(sb, <<
787 ufs_inode->ui_mtimensec = cpu_to_fs32( <<
788 <<
789 775
790 ufs_inode->ui_blocks = cpu_to_fs64(sb, 776 ufs_inode->ui_blocks = cpu_to_fs64(sb, inode->i_blocks);
791 ufs_inode->ui_flags = cpu_to_fs32(sb, 777 ufs_inode->ui_flags = cpu_to_fs32(sb, ufsi->i_flags);
792 ufs_inode->ui_gen = cpu_to_fs32(sb, in 778 ufs_inode->ui_gen = cpu_to_fs32(sb, inode->i_generation);
793 779
794 if (S_ISCHR(inode->i_mode) || S_ISBLK( 780 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
795 /* ufs_inode->ui_u2.ui_addr.ui 781 /* ufs_inode->ui_u2.ui_addr.ui_db[0] = cpu_to_fs32(sb, inode->i_rdev); */
796 ufs_inode->ui_u2.ui_addr.ui_db 782 ufs_inode->ui_u2.ui_addr.ui_db[0] = ufsi->i_u1.u2_i_data[0];
797 } else if (inode->i_blocks) { 783 } else if (inode->i_blocks) {
798 memcpy(&ufs_inode->ui_u2.ui_ad 784 memcpy(&ufs_inode->ui_u2.ui_addr, ufsi->i_u1.u2_i_data,
799 sizeof(ufs_inode->ui_u2 785 sizeof(ufs_inode->ui_u2.ui_addr));
800 } else { 786 } else {
801 memcpy(&ufs_inode->ui_u2.ui_sy 787 memcpy(&ufs_inode->ui_u2.ui_symlink, ufsi->i_u1.i_symlink,
802 sizeof(ufs_inode->ui_u2 788 sizeof(ufs_inode->ui_u2.ui_symlink));
803 } 789 }
804 790
805 if (!inode->i_nlink) 791 if (!inode->i_nlink)
806 memset (ufs_inode, 0, sizeof(s 792 memset (ufs_inode, 0, sizeof(struct ufs2_inode));
807 UFSD("EXIT\n"); 793 UFSD("EXIT\n");
808 } 794 }
809 795
810 static int ufs_update_inode(struct inode * ino 796 static int ufs_update_inode(struct inode * inode, int do_sync)
811 { 797 {
812 struct super_block *sb = inode->i_sb; 798 struct super_block *sb = inode->i_sb;
813 struct ufs_sb_private_info *uspi = UFS 799 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
814 struct buffer_head * bh; 800 struct buffer_head * bh;
815 801
816 UFSD("ENTER, ino %lu\n", inode->i_ino) 802 UFSD("ENTER, ino %lu\n", inode->i_ino);
817 803
818 if (inode->i_ino < UFS_ROOTINO || 804 if (inode->i_ino < UFS_ROOTINO ||
819 inode->i_ino > (uspi->s_ncg * uspi 805 inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
820 ufs_warning (sb, "ufs_read_ino 806 ufs_warning (sb, "ufs_read_inode", "bad inode number (%lu)\n", inode->i_ino);
821 return -1; 807 return -1;
822 } 808 }
823 809
824 bh = sb_bread(sb, ufs_inotofsba(inode- 810 bh = sb_bread(sb, ufs_inotofsba(inode->i_ino));
825 if (!bh) { 811 if (!bh) {
826 ufs_warning (sb, "ufs_read_ino 812 ufs_warning (sb, "ufs_read_inode", "unable to read inode %lu\n", inode->i_ino);
827 return -1; 813 return -1;
828 } 814 }
829 if (uspi->fs_magic == UFS2_MAGIC) { 815 if (uspi->fs_magic == UFS2_MAGIC) {
830 struct ufs2_inode *ufs2_inode 816 struct ufs2_inode *ufs2_inode = (struct ufs2_inode *)bh->b_data;
831 817
832 ufs2_update_inode(inode, 818 ufs2_update_inode(inode,
833 ufs2_inode + 819 ufs2_inode + ufs_inotofsbo(inode->i_ino));
834 } else { 820 } else {
835 struct ufs_inode *ufs_inode = 821 struct ufs_inode *ufs_inode = (struct ufs_inode *) bh->b_data;
836 822
837 ufs1_update_inode(inode, ufs_i 823 ufs1_update_inode(inode, ufs_inode + ufs_inotofsbo(inode->i_ino));
838 } 824 }
839 825
840 mark_buffer_dirty(bh); 826 mark_buffer_dirty(bh);
841 if (do_sync) 827 if (do_sync)
842 sync_dirty_buffer(bh); 828 sync_dirty_buffer(bh);
843 brelse (bh); 829 brelse (bh);
844 830
845 UFSD("EXIT\n"); 831 UFSD("EXIT\n");
846 return 0; 832 return 0;
847 } 833 }
848 834
849 int ufs_write_inode(struct inode *inode, struc 835 int ufs_write_inode(struct inode *inode, struct writeback_control *wbc)
850 { 836 {
851 return ufs_update_inode(inode, wbc->sy 837 return ufs_update_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
852 } 838 }
853 839
854 int ufs_sync_inode (struct inode *inode) 840 int ufs_sync_inode (struct inode *inode)
855 { 841 {
856 return ufs_update_inode (inode, 1); 842 return ufs_update_inode (inode, 1);
857 } 843 }
858 844
859 void ufs_evict_inode(struct inode * inode) 845 void ufs_evict_inode(struct inode * inode)
860 { 846 {
861 int want_delete = 0; 847 int want_delete = 0;
862 848
863 if (!inode->i_nlink && !is_bad_inode(i 849 if (!inode->i_nlink && !is_bad_inode(inode))
864 want_delete = 1; 850 want_delete = 1;
865 851
866 truncate_inode_pages_final(&inode->i_d 852 truncate_inode_pages_final(&inode->i_data);
867 if (want_delete) { 853 if (want_delete) {
868 inode->i_size = 0; 854 inode->i_size = 0;
869 if (inode->i_blocks && 855 if (inode->i_blocks &&
870 (S_ISREG(inode->i_mode) || 856 (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
871 S_ISLNK(inode->i_mode))) 857 S_ISLNK(inode->i_mode)))
872 ufs_truncate_blocks(in 858 ufs_truncate_blocks(inode);
873 ufs_update_inode(inode, inode_ 859 ufs_update_inode(inode, inode_needs_sync(inode));
874 } 860 }
875 861
876 invalidate_inode_buffers(inode); 862 invalidate_inode_buffers(inode);
877 clear_inode(inode); 863 clear_inode(inode);
878 864
879 if (want_delete) 865 if (want_delete)
880 ufs_free_inode(inode); 866 ufs_free_inode(inode);
881 } 867 }
882 868
883 struct to_free { 869 struct to_free {
884 struct inode *inode; 870 struct inode *inode;
885 u64 to; 871 u64 to;
886 unsigned count; 872 unsigned count;
887 }; 873 };
888 874
889 static inline void free_data(struct to_free *c 875 static inline void free_data(struct to_free *ctx, u64 from, unsigned count)
890 { 876 {
891 if (ctx->count && ctx->to != from) { 877 if (ctx->count && ctx->to != from) {
892 ufs_free_blocks(ctx->inode, ct 878 ufs_free_blocks(ctx->inode, ctx->to - ctx->count, ctx->count);
893 ctx->count = 0; 879 ctx->count = 0;
894 } 880 }
895 ctx->count += count; 881 ctx->count += count;
896 ctx->to = from + count; 882 ctx->to = from + count;
897 } 883 }
898 884
899 #define DIRECT_FRAGMENT ((inode->i_size + uspi 885 #define DIRECT_FRAGMENT ((inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift)
900 886
901 static void ufs_trunc_direct(struct inode *ino 887 static void ufs_trunc_direct(struct inode *inode)
902 { 888 {
903 struct ufs_inode_info *ufsi = UFS_I(in 889 struct ufs_inode_info *ufsi = UFS_I(inode);
904 struct super_block * sb; 890 struct super_block * sb;
905 struct ufs_sb_private_info * uspi; 891 struct ufs_sb_private_info * uspi;
906 void *p; 892 void *p;
907 u64 frag1, frag2, frag3, frag4, block1 893 u64 frag1, frag2, frag3, frag4, block1, block2;
908 struct to_free ctx = {.inode = inode}; 894 struct to_free ctx = {.inode = inode};
909 unsigned i, tmp; 895 unsigned i, tmp;
910 896
911 UFSD("ENTER: ino %lu\n", inode->i_ino) 897 UFSD("ENTER: ino %lu\n", inode->i_ino);
912 898
913 sb = inode->i_sb; 899 sb = inode->i_sb;
914 uspi = UFS_SB(sb)->s_uspi; 900 uspi = UFS_SB(sb)->s_uspi;
915 901
916 frag1 = DIRECT_FRAGMENT; 902 frag1 = DIRECT_FRAGMENT;
917 frag4 = min_t(u64, UFS_NDIR_FRAGMENT, 903 frag4 = min_t(u64, UFS_NDIR_FRAGMENT, ufsi->i_lastfrag);
918 frag2 = ((frag1 & uspi->s_fpbmask) ? ( 904 frag2 = ((frag1 & uspi->s_fpbmask) ? ((frag1 | uspi->s_fpbmask) + 1) : frag1);
919 frag3 = frag4 & ~uspi->s_fpbmask; 905 frag3 = frag4 & ~uspi->s_fpbmask;
920 block1 = block2 = 0; 906 block1 = block2 = 0;
921 if (frag2 > frag3) { 907 if (frag2 > frag3) {
922 frag2 = frag4; 908 frag2 = frag4;
923 frag3 = frag4 = 0; 909 frag3 = frag4 = 0;
924 } else if (frag2 < frag3) { 910 } else if (frag2 < frag3) {
925 block1 = ufs_fragstoblks (frag 911 block1 = ufs_fragstoblks (frag2);
926 block2 = ufs_fragstoblks (frag 912 block2 = ufs_fragstoblks (frag3);
927 } 913 }
928 914
929 UFSD("ino %lu, frag1 %llu, frag2 %llu, 915 UFSD("ino %lu, frag1 %llu, frag2 %llu, block1 %llu, block2 %llu,"
930 " frag3 %llu, frag4 %llu\n", inod 916 " frag3 %llu, frag4 %llu\n", inode->i_ino,
931 (unsigned long long)frag1, (unsig 917 (unsigned long long)frag1, (unsigned long long)frag2,
932 (unsigned long long)block1, (unsi 918 (unsigned long long)block1, (unsigned long long)block2,
933 (unsigned long long)frag3, (unsig 919 (unsigned long long)frag3, (unsigned long long)frag4);
934 920
935 if (frag1 >= frag2) 921 if (frag1 >= frag2)
936 goto next1; 922 goto next1;
937 923
938 /* 924 /*
939 * Free first free fragments 925 * Free first free fragments
940 */ 926 */
941 p = ufs_get_direct_data_ptr(uspi, ufsi 927 p = ufs_get_direct_data_ptr(uspi, ufsi, ufs_fragstoblks(frag1));
942 tmp = ufs_data_ptr_to_cpu(sb, p); 928 tmp = ufs_data_ptr_to_cpu(sb, p);
943 if (!tmp ) 929 if (!tmp )
944 ufs_panic (sb, "ufs_trunc_dire 930 ufs_panic (sb, "ufs_trunc_direct", "internal error");
945 frag2 -= frag1; 931 frag2 -= frag1;
946 frag1 = ufs_fragnum (frag1); 932 frag1 = ufs_fragnum (frag1);
947 933
948 ufs_free_fragments(inode, tmp + frag1, 934 ufs_free_fragments(inode, tmp + frag1, frag2);
949 935
950 next1: 936 next1:
951 /* 937 /*
952 * Free whole blocks 938 * Free whole blocks
953 */ 939 */
954 for (i = block1 ; i < block2; i++) { 940 for (i = block1 ; i < block2; i++) {
955 p = ufs_get_direct_data_ptr(us 941 p = ufs_get_direct_data_ptr(uspi, ufsi, i);
956 tmp = ufs_data_ptr_to_cpu(sb, 942 tmp = ufs_data_ptr_to_cpu(sb, p);
957 if (!tmp) 943 if (!tmp)
958 continue; 944 continue;
959 write_seqlock(&ufsi->meta_lock 945 write_seqlock(&ufsi->meta_lock);
960 ufs_data_ptr_clear(uspi, p); 946 ufs_data_ptr_clear(uspi, p);
961 write_sequnlock(&ufsi->meta_lo 947 write_sequnlock(&ufsi->meta_lock);
962 948
963 free_data(&ctx, tmp, uspi->s_f 949 free_data(&ctx, tmp, uspi->s_fpb);
964 } 950 }
965 951
966 free_data(&ctx, 0, 0); 952 free_data(&ctx, 0, 0);
967 953
968 if (frag3 >= frag4) 954 if (frag3 >= frag4)
969 goto next3; 955 goto next3;
970 956
971 /* 957 /*
972 * Free last free fragments 958 * Free last free fragments
973 */ 959 */
974 p = ufs_get_direct_data_ptr(uspi, ufsi 960 p = ufs_get_direct_data_ptr(uspi, ufsi, ufs_fragstoblks(frag3));
975 tmp = ufs_data_ptr_to_cpu(sb, p); 961 tmp = ufs_data_ptr_to_cpu(sb, p);
976 if (!tmp ) 962 if (!tmp )
977 ufs_panic(sb, "ufs_truncate_di 963 ufs_panic(sb, "ufs_truncate_direct", "internal error");
978 frag4 = ufs_fragnum (frag4); 964 frag4 = ufs_fragnum (frag4);
979 write_seqlock(&ufsi->meta_lock); 965 write_seqlock(&ufsi->meta_lock);
980 ufs_data_ptr_clear(uspi, p); 966 ufs_data_ptr_clear(uspi, p);
981 write_sequnlock(&ufsi->meta_lock); 967 write_sequnlock(&ufsi->meta_lock);
982 968
983 ufs_free_fragments (inode, tmp, frag4) 969 ufs_free_fragments (inode, tmp, frag4);
984 next3: 970 next3:
985 971
986 UFSD("EXIT: ino %lu\n", inode->i_ino); 972 UFSD("EXIT: ino %lu\n", inode->i_ino);
987 } 973 }
988 974
989 static void free_full_branch(struct inode *ino 975 static void free_full_branch(struct inode *inode, u64 ind_block, int depth)
990 { 976 {
991 struct super_block *sb = inode->i_sb; 977 struct super_block *sb = inode->i_sb;
992 struct ufs_sb_private_info *uspi = UFS 978 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
993 struct ufs_buffer_head *ubh = ubh_brea 979 struct ufs_buffer_head *ubh = ubh_bread(sb, ind_block, uspi->s_bsize);
994 unsigned i; 980 unsigned i;
995 981
996 if (!ubh) 982 if (!ubh)
997 return; 983 return;
998 984
999 if (--depth) { 985 if (--depth) {
1000 for (i = 0; i < uspi->s_apb; 986 for (i = 0; i < uspi->s_apb; i++) {
1001 void *p = ubh_get_dat 987 void *p = ubh_get_data_ptr(uspi, ubh, i);
1002 u64 block = ufs_data_ 988 u64 block = ufs_data_ptr_to_cpu(sb, p);
1003 if (block) 989 if (block)
1004 free_full_bra 990 free_full_branch(inode, block, depth);
1005 } 991 }
1006 } else { 992 } else {
1007 struct to_free ctx = {.inode 993 struct to_free ctx = {.inode = inode};
1008 994
1009 for (i = 0; i < uspi->s_apb; 995 for (i = 0; i < uspi->s_apb; i++) {
1010 void *p = ubh_get_dat 996 void *p = ubh_get_data_ptr(uspi, ubh, i);
1011 u64 block = ufs_data_ 997 u64 block = ufs_data_ptr_to_cpu(sb, p);
1012 if (block) 998 if (block)
1013 free_data(&ct 999 free_data(&ctx, block, uspi->s_fpb);
1014 } 1000 }
1015 free_data(&ctx, 0, 0); 1001 free_data(&ctx, 0, 0);
1016 } 1002 }
1017 1003
1018 ubh_bforget(ubh); 1004 ubh_bforget(ubh);
1019 ufs_free_blocks(inode, ind_block, usp 1005 ufs_free_blocks(inode, ind_block, uspi->s_fpb);
1020 } 1006 }
1021 1007
1022 static void free_branch_tail(struct inode *in 1008 static void free_branch_tail(struct inode *inode, unsigned from, struct ufs_buffer_head *ubh, int depth)
1023 { 1009 {
1024 struct super_block *sb = inode->i_sb; 1010 struct super_block *sb = inode->i_sb;
1025 struct ufs_sb_private_info *uspi = UF 1011 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
1026 unsigned i; 1012 unsigned i;
1027 1013
1028 if (--depth) { 1014 if (--depth) {
1029 for (i = from; i < uspi->s_ap 1015 for (i = from; i < uspi->s_apb ; i++) {
1030 void *p = ubh_get_dat 1016 void *p = ubh_get_data_ptr(uspi, ubh, i);
1031 u64 block = ufs_data_ 1017 u64 block = ufs_data_ptr_to_cpu(sb, p);
1032 if (block) { 1018 if (block) {
1033 write_seqlock 1019 write_seqlock(&UFS_I(inode)->meta_lock);
1034 ufs_data_ptr_ 1020 ufs_data_ptr_clear(uspi, p);
1035 write_sequnlo 1021 write_sequnlock(&UFS_I(inode)->meta_lock);
1036 ubh_mark_buff 1022 ubh_mark_buffer_dirty(ubh);
1037 free_full_bra 1023 free_full_branch(inode, block, depth);
1038 } 1024 }
1039 } 1025 }
1040 } else { 1026 } else {
1041 struct to_free ctx = {.inode 1027 struct to_free ctx = {.inode = inode};
1042 1028
1043 for (i = from; i < uspi->s_ap 1029 for (i = from; i < uspi->s_apb; i++) {
1044 void *p = ubh_get_dat 1030 void *p = ubh_get_data_ptr(uspi, ubh, i);
1045 u64 block = ufs_data_ 1031 u64 block = ufs_data_ptr_to_cpu(sb, p);
1046 if (block) { 1032 if (block) {
1047 write_seqlock 1033 write_seqlock(&UFS_I(inode)->meta_lock);
1048 ufs_data_ptr_ 1034 ufs_data_ptr_clear(uspi, p);
1049 write_sequnlo 1035 write_sequnlock(&UFS_I(inode)->meta_lock);
1050 ubh_mark_buff 1036 ubh_mark_buffer_dirty(ubh);
1051 free_data(&ct 1037 free_data(&ctx, block, uspi->s_fpb);
1052 } 1038 }
1053 } 1039 }
1054 free_data(&ctx, 0, 0); 1040 free_data(&ctx, 0, 0);
1055 } 1041 }
1056 if (IS_SYNC(inode) && ubh_buffer_dirt 1042 if (IS_SYNC(inode) && ubh_buffer_dirty(ubh))
1057 ubh_sync_block(ubh); 1043 ubh_sync_block(ubh);
1058 ubh_brelse(ubh); 1044 ubh_brelse(ubh);
1059 } 1045 }
1060 1046
1061 static int ufs_alloc_lastblock(struct inode * 1047 static int ufs_alloc_lastblock(struct inode *inode, loff_t size)
1062 { 1048 {
1063 int err = 0; 1049 int err = 0;
1064 struct super_block *sb = inode->i_sb; 1050 struct super_block *sb = inode->i_sb;
1065 struct address_space *mapping = inode 1051 struct address_space *mapping = inode->i_mapping;
1066 struct ufs_sb_private_info *uspi = UF 1052 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
1067 unsigned i, end; 1053 unsigned i, end;
1068 sector_t lastfrag; 1054 sector_t lastfrag;
1069 struct folio *folio; !! 1055 struct page *lastpage;
1070 struct buffer_head *bh; 1056 struct buffer_head *bh;
1071 u64 phys64; 1057 u64 phys64;
1072 1058
1073 lastfrag = (size + uspi->s_fsize - 1) 1059 lastfrag = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
1074 1060
1075 if (!lastfrag) 1061 if (!lastfrag)
1076 goto out; 1062 goto out;
1077 1063
1078 lastfrag--; 1064 lastfrag--;
1079 1065
1080 folio = ufs_get_locked_folio(mapping, !! 1066 lastpage = ufs_get_locked_page(mapping, lastfrag >>
1081 (PAGE_ 1067 (PAGE_SHIFT - inode->i_blkbits));
1082 if (IS_ERR(folio)) { !! 1068 if (IS_ERR(lastpage)) {
1083 err = -EIO; !! 1069 err = -EIO;
1084 goto out; !! 1070 goto out;
1085 } !! 1071 }
>> 1072
>> 1073 end = lastfrag & ((1 << (PAGE_SHIFT - inode->i_blkbits)) - 1);
>> 1074 bh = page_buffers(lastpage);
>> 1075 for (i = 0; i < end; ++i)
>> 1076 bh = bh->b_this_page;
1086 1077
1087 end = lastfrag & ((1 << (PAGE_SHIFT - <<
1088 bh = folio_buffers(folio); <<
1089 for (i = 0; i < end; ++i) <<
1090 bh = bh->b_this_page; <<
1091 1078
1092 err = ufs_getfrag_block(inode, lastfra 1079 err = ufs_getfrag_block(inode, lastfrag, bh, 1);
1093 1080
1094 if (unlikely(err)) 1081 if (unlikely(err))
1095 goto out_unlock; 1082 goto out_unlock;
1096 1083
1097 if (buffer_new(bh)) { 1084 if (buffer_new(bh)) {
1098 clear_buffer_new(bh); 1085 clear_buffer_new(bh);
1099 clean_bdev_bh_alias(bh); 1086 clean_bdev_bh_alias(bh);
1100 /* 1087 /*
1101 * we do not zeroize fragment, 1088 * we do not zeroize fragment, because of
1102 * if it maped to hole, it alr 1089 * if it maped to hole, it already contains zeroes
1103 */ 1090 */
1104 set_buffer_uptodate(bh); 1091 set_buffer_uptodate(bh);
1105 mark_buffer_dirty(bh); 1092 mark_buffer_dirty(bh);
1106 folio_mark_dirty(folio); !! 1093 set_page_dirty(lastpage);
1107 } 1094 }
1108 1095
1109 if (lastfrag >= UFS_IND_FRAGMENT) { 1096 if (lastfrag >= UFS_IND_FRAGMENT) {
1110 end = uspi->s_fpb - ufs_fragnu 1097 end = uspi->s_fpb - ufs_fragnum(lastfrag) - 1;
1111 phys64 = bh->b_blocknr + 1; 1098 phys64 = bh->b_blocknr + 1;
1112 for (i = 0; i < end; ++i) { 1099 for (i = 0; i < end; ++i) {
1113 bh = sb_getblk(sb, i + 1100 bh = sb_getblk(sb, i + phys64);
1114 lock_buffer(bh); 1101 lock_buffer(bh);
1115 memset(bh->b_data, 0, 1102 memset(bh->b_data, 0, sb->s_blocksize);
1116 set_buffer_uptodate(bh 1103 set_buffer_uptodate(bh);
1117 mark_buffer_dirty(bh); 1104 mark_buffer_dirty(bh);
1118 unlock_buffer(bh); 1105 unlock_buffer(bh);
1119 sync_dirty_buffer(bh); 1106 sync_dirty_buffer(bh);
1120 brelse(bh); 1107 brelse(bh);
1121 } 1108 }
1122 } 1109 }
1123 out_unlock: 1110 out_unlock:
1124 ufs_put_locked_folio(folio); !! 1111 ufs_put_locked_page(lastpage);
1125 out: 1112 out:
1126 return err; 1113 return err;
1127 } 1114 }
1128 1115
1129 static void ufs_truncate_blocks(struct inode 1116 static void ufs_truncate_blocks(struct inode *inode)
1130 { 1117 {
1131 struct ufs_inode_info *ufsi = UFS_I(i 1118 struct ufs_inode_info *ufsi = UFS_I(inode);
1132 struct super_block *sb = inode->i_sb; 1119 struct super_block *sb = inode->i_sb;
1133 struct ufs_sb_private_info *uspi = UF 1120 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
1134 unsigned offsets[4]; 1121 unsigned offsets[4];
1135 int depth; 1122 int depth;
1136 int depth2; 1123 int depth2;
1137 unsigned i; 1124 unsigned i;
1138 struct ufs_buffer_head *ubh[3]; 1125 struct ufs_buffer_head *ubh[3];
1139 void *p; 1126 void *p;
1140 u64 block; 1127 u64 block;
1141 1128
1142 if (inode->i_size) { 1129 if (inode->i_size) {
1143 sector_t last = (inode->i_siz 1130 sector_t last = (inode->i_size - 1) >> uspi->s_bshift;
1144 depth = ufs_block_to_path(ino 1131 depth = ufs_block_to_path(inode, last, offsets);
1145 if (!depth) 1132 if (!depth)
1146 return; 1133 return;
1147 } else { 1134 } else {
1148 depth = 1; 1135 depth = 1;
1149 } 1136 }
1150 1137
1151 for (depth2 = depth - 1; depth2; dept 1138 for (depth2 = depth - 1; depth2; depth2--)
1152 if (offsets[depth2] != uspi-> 1139 if (offsets[depth2] != uspi->s_apb - 1)
1153 break; 1140 break;
1154 1141
1155 mutex_lock(&ufsi->truncate_mutex); 1142 mutex_lock(&ufsi->truncate_mutex);
1156 if (depth == 1) { 1143 if (depth == 1) {
1157 ufs_trunc_direct(inode); 1144 ufs_trunc_direct(inode);
1158 offsets[0] = UFS_IND_BLOCK; 1145 offsets[0] = UFS_IND_BLOCK;
1159 } else { 1146 } else {
1160 /* get the blocks that should 1147 /* get the blocks that should be partially emptied */
1161 p = ufs_get_direct_data_ptr(u 1148 p = ufs_get_direct_data_ptr(uspi, ufsi, offsets[0]++);
1162 for (i = 0; i < depth2; i++) 1149 for (i = 0; i < depth2; i++) {
1163 block = ufs_data_ptr_ 1150 block = ufs_data_ptr_to_cpu(sb, p);
1164 if (!block) 1151 if (!block)
1165 break; 1152 break;
1166 ubh[i] = ubh_bread(sb 1153 ubh[i] = ubh_bread(sb, block, uspi->s_bsize);
1167 if (!ubh[i]) { 1154 if (!ubh[i]) {
1168 write_seqlock 1155 write_seqlock(&ufsi->meta_lock);
1169 ufs_data_ptr_ 1156 ufs_data_ptr_clear(uspi, p);
1170 write_sequnlo 1157 write_sequnlock(&ufsi->meta_lock);
1171 break; 1158 break;
1172 } 1159 }
1173 p = ubh_get_data_ptr( 1160 p = ubh_get_data_ptr(uspi, ubh[i], offsets[i + 1]++);
1174 } 1161 }
1175 while (i--) 1162 while (i--)
1176 free_branch_tail(inod 1163 free_branch_tail(inode, offsets[i + 1], ubh[i], depth - i - 1);
1177 } 1164 }
1178 for (i = offsets[0]; i <= UFS_TIND_BL 1165 for (i = offsets[0]; i <= UFS_TIND_BLOCK; i++) {
1179 p = ufs_get_direct_data_ptr(u 1166 p = ufs_get_direct_data_ptr(uspi, ufsi, i);
1180 block = ufs_data_ptr_to_cpu(s 1167 block = ufs_data_ptr_to_cpu(sb, p);
1181 if (block) { 1168 if (block) {
1182 write_seqlock(&ufsi-> 1169 write_seqlock(&ufsi->meta_lock);
1183 ufs_data_ptr_clear(us 1170 ufs_data_ptr_clear(uspi, p);
1184 write_sequnlock(&ufsi 1171 write_sequnlock(&ufsi->meta_lock);
1185 free_full_branch(inod 1172 free_full_branch(inode, block, i - UFS_IND_BLOCK + 1);
1186 } 1173 }
1187 } 1174 }
1188 read_seqlock_excl(&ufsi->meta_lock); 1175 read_seqlock_excl(&ufsi->meta_lock);
1189 ufsi->i_lastfrag = DIRECT_FRAGMENT; 1176 ufsi->i_lastfrag = DIRECT_FRAGMENT;
1190 read_sequnlock_excl(&ufsi->meta_lock) 1177 read_sequnlock_excl(&ufsi->meta_lock);
1191 mark_inode_dirty(inode); 1178 mark_inode_dirty(inode);
1192 mutex_unlock(&ufsi->truncate_mutex); 1179 mutex_unlock(&ufsi->truncate_mutex);
1193 } 1180 }
1194 1181
1195 static int ufs_truncate(struct inode *inode, 1182 static int ufs_truncate(struct inode *inode, loff_t size)
1196 { 1183 {
1197 int err = 0; 1184 int err = 0;
1198 1185
1199 UFSD("ENTER: ino %lu, i_size: %llu, o 1186 UFSD("ENTER: ino %lu, i_size: %llu, old_i_size: %llu\n",
1200 inode->i_ino, (unsigned long lon 1187 inode->i_ino, (unsigned long long)size,
1201 (unsigned long long)i_size_read( 1188 (unsigned long long)i_size_read(inode));
1202 1189
1203 if (!(S_ISREG(inode->i_mode) || S_ISD 1190 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1204 S_ISLNK(inode->i_mode))) 1191 S_ISLNK(inode->i_mode)))
1205 return -EINVAL; 1192 return -EINVAL;
1206 if (IS_APPEND(inode) || IS_IMMUTABLE( 1193 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1207 return -EPERM; 1194 return -EPERM;
1208 1195
1209 err = ufs_alloc_lastblock(inode, size 1196 err = ufs_alloc_lastblock(inode, size);
1210 1197
1211 if (err) 1198 if (err)
1212 goto out; 1199 goto out;
1213 1200
1214 block_truncate_page(inode->i_mapping, 1201 block_truncate_page(inode->i_mapping, size, ufs_getfrag_block);
1215 1202
1216 truncate_setsize(inode, size); 1203 truncate_setsize(inode, size);
1217 1204
1218 ufs_truncate_blocks(inode); 1205 ufs_truncate_blocks(inode);
1219 inode_set_mtime_to_ts(inode, inode_se !! 1206 inode->i_mtime = inode->i_ctime = current_time(inode);
1220 mark_inode_dirty(inode); 1207 mark_inode_dirty(inode);
1221 out: 1208 out:
1222 UFSD("EXIT: err %d\n", err); 1209 UFSD("EXIT: err %d\n", err);
1223 return err; 1210 return err;
1224 } 1211 }
1225 1212
1226 int ufs_setattr(struct mnt_idmap *idmap, stru !! 1213 int ufs_setattr(struct dentry *dentry, struct iattr *attr)
1227 struct iattr *attr) <<
1228 { 1214 {
1229 struct inode *inode = d_inode(dentry) 1215 struct inode *inode = d_inode(dentry);
1230 unsigned int ia_valid = attr->ia_vali 1216 unsigned int ia_valid = attr->ia_valid;
1231 int error; 1217 int error;
1232 1218
1233 error = setattr_prepare(&nop_mnt_idma !! 1219 error = setattr_prepare(dentry, attr);
1234 if (error) 1220 if (error)
1235 return error; 1221 return error;
1236 1222
1237 if (ia_valid & ATTR_SIZE && attr->ia_ 1223 if (ia_valid & ATTR_SIZE && attr->ia_size != inode->i_size) {
1238 error = ufs_truncate(inode, a 1224 error = ufs_truncate(inode, attr->ia_size);
1239 if (error) 1225 if (error)
1240 return error; 1226 return error;
1241 } 1227 }
1242 1228
1243 setattr_copy(&nop_mnt_idmap, inode, a !! 1229 setattr_copy(inode, attr);
1244 mark_inode_dirty(inode); 1230 mark_inode_dirty(inode);
1245 return 0; 1231 return 0;
1246 } 1232 }
1247 1233
1248 const struct inode_operations ufs_file_inode_ 1234 const struct inode_operations ufs_file_inode_operations = {
1249 .setattr = ufs_setattr, 1235 .setattr = ufs_setattr,
1250 }; 1236 };
1251 1237
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.