~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/block/partitions/aix.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  *  fs/partitions/aix.c
  4  *
  5  *  Copyright (C) 2012-2013 Philippe De Muyter <phdm@macqel.be>
  6  */
  7 
  8 #include "check.h"
  9 #include "aix.h"
 10 
 11 struct lvm_rec {
 12         char lvm_id[4]; /* "_LVM" */
 13         char reserved4[16];
 14         __be32 lvmarea_len;
 15         __be32 vgda_len;
 16         __be32 vgda_psn[2];
 17         char reserved36[10];
 18         __be16 pp_size; /* log2(pp_size) */
 19         char reserved46[12];
 20         __be16 version;
 21         };
 22 
 23 struct vgda {
 24         __be32 secs;
 25         __be32 usec;
 26         char reserved8[16];
 27         __be16 numlvs;
 28         __be16 maxlvs;
 29         __be16 pp_size;
 30         __be16 numpvs;
 31         __be16 total_vgdas;
 32         __be16 vgda_size;
 33         };
 34 
 35 struct lvd {
 36         __be16 lv_ix;
 37         __be16 res2;
 38         __be16 res4;
 39         __be16 maxsize;
 40         __be16 lv_state;
 41         __be16 mirror;
 42         __be16 mirror_policy;
 43         __be16 num_lps;
 44         __be16 res10[8];
 45         };
 46 
 47 struct lvname {
 48         char name[64];
 49         };
 50 
 51 struct ppe {
 52         __be16 lv_ix;
 53         unsigned short res2;
 54         unsigned short res4;
 55         __be16 lp_ix;
 56         unsigned short res8[12];
 57         };
 58 
 59 struct pvd {
 60         char reserved0[16];
 61         __be16 pp_count;
 62         char reserved18[2];
 63         __be32 psn_part1;
 64         char reserved24[8];
 65         struct ppe ppe[1016];
 66         };
 67 
 68 #define LVM_MAXLVS 256
 69 
 70 /**
 71  * last_lba(): return number of last logical block of device
 72  * @bdev: block device
 73  *
 74  * Description: Returns last LBA value on success, 0 on error.
 75  * This is stored (by sd and ide-geometry) in
 76  *  the part[0] entry for this disk, and is the number of
 77  *  physical sectors available on the disk.
 78  */
 79 static u64 last_lba(struct block_device *bdev)
 80 {
 81         if (!bdev || !bdev->bd_inode)
 82                 return 0;
 83         return (bdev->bd_inode->i_size >> 9) - 1ULL;
 84 }
 85 
 86 /**
 87  * read_lba(): Read bytes from disk, starting at given LBA
 88  * @state
 89  * @lba
 90  * @buffer
 91  * @count
 92  *
 93  * Description:  Reads @count bytes from @state->bdev into @buffer.
 94  * Returns number of bytes read on success, 0 on error.
 95  */
 96 static size_t read_lba(struct parsed_partitions *state, u64 lba, u8 *buffer,
 97                         size_t count)
 98 {
 99         size_t totalreadcount = 0;
100 
101         if (!buffer || lba + count / 512 > last_lba(state->bdev))
102                 return 0;
103 
104         while (count) {
105                 int copied = 512;
106                 Sector sect;
107                 unsigned char *data = read_part_sector(state, lba++, &sect);
108                 if (!data)
109                         break;
110                 if (copied > count)
111                         copied = count;
112                 memcpy(buffer, data, copied);
113                 put_dev_sector(sect);
114                 buffer += copied;
115                 totalreadcount += copied;
116                 count -= copied;
117         }
118         return totalreadcount;
119 }
120 
121 /**
122  * alloc_pvd(): reads physical volume descriptor
123  * @state
124  * @lba
125  *
126  * Description: Returns pvd on success,  NULL on error.
127  * Allocates space for pvd and fill it with disk blocks at @lba
128  * Notes: remember to free pvd when you're done!
129  */
130 static struct pvd *alloc_pvd(struct parsed_partitions *state, u32 lba)
131 {
132         size_t count = sizeof(struct pvd);
133         struct pvd *p;
134 
135         p = kmalloc(count, GFP_KERNEL);
136         if (!p)
137                 return NULL;
138 
139         if (read_lba(state, lba, (u8 *) p, count) < count) {
140                 kfree(p);
141                 return NULL;
142         }
143         return p;
144 }
145 
146 /**
147  * alloc_lvn(): reads logical volume names
148  * @state
149  * @lba
150  *
151  * Description: Returns lvn on success,  NULL on error.
152  * Allocates space for lvn and fill it with disk blocks at @lba
153  * Notes: remember to free lvn when you're done!
154  */
155 static struct lvname *alloc_lvn(struct parsed_partitions *state, u32 lba)
156 {
157         size_t count = sizeof(struct lvname) * LVM_MAXLVS;
158         struct lvname *p;
159 
160         p = kmalloc(count, GFP_KERNEL);
161         if (!p)
162                 return NULL;
163 
164         if (read_lba(state, lba, (u8 *) p, count) < count) {
165                 kfree(p);
166                 return NULL;
167         }
168         return p;
169 }
170 
171 int aix_partition(struct parsed_partitions *state)
172 {
173         int ret = 0;
174         Sector sect;
175         unsigned char *d;
176         u32 pp_bytes_size;
177         u32 pp_blocks_size = 0;
178         u32 vgda_sector = 0;
179         u32 vgda_len = 0;
180         int numlvs = 0;
181         struct pvd *pvd;
182         struct lv_info {
183                 unsigned short pps_per_lv;
184                 unsigned short pps_found;
185                 unsigned char lv_is_contiguous;
186         } *lvip;
187         struct lvname *n = NULL;
188 
189         d = read_part_sector(state, 7, &sect);
190         if (d) {
191                 struct lvm_rec *p = (struct lvm_rec *)d;
192                 u16 lvm_version = be16_to_cpu(p->version);
193                 char tmp[64];
194 
195                 if (lvm_version == 1) {
196                         int pp_size_log2 = be16_to_cpu(p->pp_size);
197 
198                         pp_bytes_size = 1 << pp_size_log2;
199                         pp_blocks_size = pp_bytes_size / 512;
200                         snprintf(tmp, sizeof(tmp),
201                                 " AIX LVM header version %u found\n",
202                                 lvm_version);
203                         vgda_len = be32_to_cpu(p->vgda_len);
204                         vgda_sector = be32_to_cpu(p->vgda_psn[0]);
205                 } else {
206                         snprintf(tmp, sizeof(tmp),
207                                 " unsupported AIX LVM version %d found\n",
208                                 lvm_version);
209                 }
210                 strlcat(state->pp_buf, tmp, PAGE_SIZE);
211                 put_dev_sector(sect);
212         }
213         if (vgda_sector && (d = read_part_sector(state, vgda_sector, &sect))) {
214                 struct vgda *p = (struct vgda *)d;
215 
216                 numlvs = be16_to_cpu(p->numlvs);
217                 put_dev_sector(sect);
218         }
219         lvip = kcalloc(state->limit, sizeof(struct lv_info), GFP_KERNEL);
220         if (!lvip)
221                 return 0;
222         if (numlvs && (d = read_part_sector(state, vgda_sector + 1, &sect))) {
223                 struct lvd *p = (struct lvd *)d;
224                 int i;
225 
226                 n = alloc_lvn(state, vgda_sector + vgda_len - 33);
227                 if (n) {
228                         int foundlvs = 0;
229 
230                         for (i = 0; foundlvs < numlvs && i < state->limit; i += 1) {
231                                 lvip[i].pps_per_lv = be16_to_cpu(p[i].num_lps);
232                                 if (lvip[i].pps_per_lv)
233                                         foundlvs += 1;
234                         }
235                 }
236                 put_dev_sector(sect);
237         }
238         pvd = alloc_pvd(state, vgda_sector + 17);
239         if (pvd) {
240                 int numpps = be16_to_cpu(pvd->pp_count);
241                 int psn_part1 = be32_to_cpu(pvd->psn_part1);
242                 int i;
243                 int cur_lv_ix = -1;
244                 int next_lp_ix = 1;
245                 int lp_ix;
246 
247                 for (i = 0; i < numpps; i += 1) {
248                         struct ppe *p = pvd->ppe + i;
249                         unsigned int lv_ix;
250 
251                         lp_ix = be16_to_cpu(p->lp_ix);
252                         if (!lp_ix) {
253                                 next_lp_ix = 1;
254                                 continue;
255                         }
256                         lv_ix = be16_to_cpu(p->lv_ix) - 1;
257                         if (lv_ix >= state->limit) {
258                                 cur_lv_ix = -1;
259                                 continue;
260                         }
261                         lvip[lv_ix].pps_found += 1;
262                         if (lp_ix == 1) {
263                                 cur_lv_ix = lv_ix;
264                                 next_lp_ix = 1;
265                         } else if (lv_ix != cur_lv_ix || lp_ix != next_lp_ix) {
266                                 next_lp_ix = 1;
267                                 continue;
268                         }
269                         if (lp_ix == lvip[lv_ix].pps_per_lv) {
270                                 char tmp[70];
271 
272                                 put_partition(state, lv_ix + 1,
273                                   (i + 1 - lp_ix) * pp_blocks_size + psn_part1,
274                                   lvip[lv_ix].pps_per_lv * pp_blocks_size);
275                                 snprintf(tmp, sizeof(tmp), " <%s>\n",
276                                          n[lv_ix].name);
277                                 strlcat(state->pp_buf, tmp, PAGE_SIZE);
278                                 lvip[lv_ix].lv_is_contiguous = 1;
279                                 ret = 1;
280                                 next_lp_ix = 1;
281                         } else
282                                 next_lp_ix += 1;
283                 }
284                 for (i = 0; i < state->limit; i += 1)
285                         if (lvip[i].pps_found && !lvip[i].lv_is_contiguous)
286                                 pr_warn("partition %s (%u pp's found) is "
287                                         "not contiguous\n",
288                                         n[i].name, lvip[i].pps_found);
289                 kfree(pvd);
290         }
291         kfree(n);
292         kfree(lvip);
293         return ret;
294 }
295 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp