summaryrefslogtreecommitdiff
path: root/ufs/ufs.h
blob: f59784d5ac17a101a5bc298eeea98f7fa90e11e1 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
/*
   Copyright (C) 1994, 1995, 1996, 1997, 1999 Free Software Foundation

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2, or (at
   your option) any later version.

   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */

#include <mach.h>
#include <hurd.h>
#include <sys/mman.h>
#include <hurd/ports.h>
#include <hurd/pager.h>
#include <hurd/fshelp.h>
#include <hurd/iohelp.h>
#include <hurd/diskfs.h>
#include <sys/mman.h>
#include <assert.h>
#include <features.h>
#include "fs.h"
#include "dinode.h"

#ifdef UFS_DEFINE_EI
#define UFS_EI
#else
#define UFS_EI __extern_inline
#endif

/* Define this if memory objects should not be cached by the kernel.
   Normally, don't define it, but defining it causes a much greater rate
   of paging requests, which may be helpful in catching bugs. */

/* #undef DONT_CACHE_MEMORY_OBJECTS */

struct disknode
{
  ino_t number;

  int dir_idx;

  /* For a directory, this array holds the number of directory entries in
     each DIRBLKSIZE piece of the directory. */
  int *dirents;

  /* Links on hash list. */
  struct node *hnext, **hprevp;

  struct rwlock allocptrlock;

  struct dirty_indir *dirty;

  struct user_pager_info *fileinfo;
};

/* Identifies a particular block and where it's found
   when interpreting indirect block structure.  */
struct iblock_spec
{
  /* Disk address of block */
  daddr_t bno;

  /* Offset in next block up; -1 if it's in the inode itself. */
  int offset;
};

/* Identifies an indirect block owned by this file which
   might be dirty. */
struct dirty_indir
{
  daddr_t bno;			/* Disk address of block. */
  struct dirty_indir *next;
};

struct user_pager_info
{
  struct node *np;
  enum pager_type
    {
      DISK,
      FILE_DATA,
    } type;
  struct pager *p;
  vm_prot_t max_prot;

  vm_offset_t allow_unlocked_pagein;
  vm_size_t unlocked_pagein_length;
};

#include <hurd/diskfs-pager.h>

/* The physical media.  */
extern struct store *store;
/* What the user specified.  */
extern struct store_parsed *store_parsed;

/* Mapped image of the disk.  */
extern void *disk_image;

extern void *zeroblock;

extern struct fs *sblock;
extern struct csum *csum;
int sblock_dirty;
int csum_dirty;

spin_lock_t node2pagelock;

spin_lock_t alloclock;

spin_lock_t gennumberlock;
u_long nextgennumber;

spin_lock_t unlocked_pagein_lock;

/* The compat_mode specifies whether or not we write
   extensions onto the disk. */
enum compat_mode
{
  COMPAT_GNU = 0,
  COMPAT_BSD42 = 1,
  COMPAT_BSD44 = 2,
} compat_mode;

/* If this is set, then this filesystem has two extensions:
   1) directory entries include the type field.
   2) symlink targets might be written directly in the di_db field
      of the dinode. */
int direct_symlink_extension;

/* If this is set, then the disk is byteswapped from native order. */
int swab_disk;

/* Number of device blocks per DEV_BSIZE block.  */
unsigned log2_dev_blocks_per_dev_bsize;

/* Handy macros */
#define DEV_BSIZE 512
#define NBBY 8
#define btodb(n) ((n) / DEV_BSIZE)
#define howmany(x,y) (((x)+((y)-1))/(y))
#define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
#define isclr(a, i) (((a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
#define isset(a, i) ((a)[(i)/NBBY] & (1<<((i)%NBBY)))
#define setbit(a,i) ((a)[(i)/NBBY] |= 1<<((i)%NBBY))
#define clrbit(a,i) ((a)[(i)/NBBY] &= ~(1<<(i)%NBBY))
#define fsaddr(fs,n) (fsbtodb(fs,n)*DEV_BSIZE)


/* Functions for looking inside disk_image */

extern struct dinode * dino (ino_t inum);
extern daddr_t * indir_block (daddr_t bno);
extern struct cg * cg_locate (int ncg);
extern void sync_disk_blocks (daddr_t blkno, size_t nbytes, int wait);
extern void sync_dinode (int inum, int wait);
extern short swab_short (short arg);
extern long swab_long (long arg);
extern long long swab_long_long (long long arg);

#if defined(__USE_EXTERN_INLINES) || defined(UFS_DEFINE_EI)
/* Convert an inode number to the dinode on disk. */
UFS_EI struct dinode *
dino (ino_t inum)
{
  return (struct dinode *)
    (disk_image
     + fsaddr (sblock, ino_to_fsba (sblock, inum))
     + ino_to_fsbo (sblock, inum) * sizeof (struct dinode));
}

/* Convert a indirect block number to a daddr_t table. */
UFS_EI daddr_t *
indir_block (daddr_t bno)
{
  return (daddr_t *) (disk_image + fsaddr (sblock, bno));
}

/* Convert a cg number to the cylinder group. */
UFS_EI struct cg *
cg_locate (int ncg)
{
  return (struct cg *) (disk_image + fsaddr (sblock, cgtod (sblock, ncg)));
}

/* Sync part of the disk */
UFS_EI void
sync_disk_blocks (daddr_t blkno, size_t nbytes, int wait)
{
  pager_sync_some (diskfs_disk_pager, fsaddr (sblock, blkno), nbytes, wait);
}

/* Sync an disk inode */
UFS_EI void
sync_dinode (int inum, int wait)
{
  sync_disk_blocks (ino_to_fsba (sblock, inum), sblock->fs_fsize, wait);
}


/* Functions for byte swapping */
UFS_EI short
swab_short (short arg)
{
  return (((arg & 0xff) << 8)
	  | ((arg & 0xff00) >> 8));
}

UFS_EI long
swab_long (long arg)
{
  return (((long) swab_short (arg & 0xffff) << 16)
	  | swab_short ((arg & 0xffff0000) >> 16));
}

UFS_EI long long
swab_long_long (long long arg)
{
  return (((long long) swab_long (arg & 0xffffffff) << 32)
	  | swab_long ((arg & 0xffffffff00000000LL) >> 32));
}
#endif /* Use extern inlines.  */

/* Return ENTRY, after byteswapping it if necessary */
#define read_disk_entry(entry)						    \
({ 									    \
  typeof (entry) ret;							    \
  if (!swab_disk || sizeof (entry) == 1)				    \
    ret = (entry);							    \
  else if (sizeof (entry) == 2)					            \
    ret = swab_short (entry);						    \
  else if (sizeof (entry) == 4)					            \
    ret = swab_long (entry);						    \
  else									    \
    abort ();								    \
  ret;									    \
})

/* Execute A = B, but byteswap it along the way if necessary */
#define write_disk_entry(a,b)						    \
({									    \
  if (!swab_disk || sizeof (a) == 1)					    \
    ((a) = (b));							    \
  else if (sizeof (a) == 2)						    \
    ((a) = (swab_short (b)));						    \
  else if (sizeof (a) == 4)						    \
    ((a) = (swab_long (b)));						    \
  else									    \
    abort ();								    \
})





/* From alloc.c: */
error_t ffs_alloc (struct node *, daddr_t, daddr_t, int, daddr_t *,
		   struct protid *);
void ffs_blkfree(struct node *, daddr_t bno, long size);
daddr_t ffs_blkpref (struct node *, daddr_t, int, daddr_t *);
error_t ffs_realloccg(struct node *, daddr_t, daddr_t,
		  int, int, daddr_t *, struct protid *);

/* From bmap.c */
error_t fetch_indir_spec (struct node *, daddr_t, struct iblock_spec *);
void mark_indir_dirty (struct node *, daddr_t);

/* From hyper.c: */
void get_hypermetadata (void);
void copy_sblock (void);

/* From inode.c: */
struct node *ifind (ino_t ino);
void inode_init (void);
void write_all_disknodes (void);

/* From pager.c: */
void create_disk_pager (void);
void din_map (struct node *);
void sin_map (struct node *);
void sin_remap (struct node *, int);
void sin_unmap (struct node *);
void din_unmap (struct node *);
void drop_pager_softrefs (struct node *);
void allow_pager_softrefs (struct node *);
void flush_node_pager (struct node *);

/* From subr.c: */
void ffs_fragacct (struct fs *, int, long [], int);
int ffs_isblock(struct fs *, u_char *, daddr_t);
void ffs_clrblock(struct fs *, u_char *, daddr_t);
void ffs_setblock (struct fs *, u_char *, daddr_t);
int skpc (int, int, char *);
int scanc (u_int, u_char *, u_char [], int);

/* From pokeloc.c: */
void record_poke (void *, vm_size_t);
void sync_disk (int);
void flush_pokes ();