@@ -78,23 +78,14 @@ static void rd_detach_hba(struct se_hba *hba)
7878 hba -> hba_ptr = NULL ;
7979}
8080
81- /* rd_release_device_space():
82- *
83- *
84- */
85- static void rd_release_device_space (struct rd_dev * rd_dev )
81+ static u32 rd_release_sgl_table (struct rd_dev * rd_dev , struct rd_dev_sg_table * sg_table ,
82+ u32 sg_table_count )
8683{
87- u32 i , j , page_count = 0 , sg_per_table ;
88- struct rd_dev_sg_table * sg_table ;
8984 struct page * pg ;
9085 struct scatterlist * sg ;
86+ u32 i , j , page_count = 0 , sg_per_table ;
9187
92- if (!rd_dev -> sg_table_array || !rd_dev -> sg_table_count )
93- return ;
94-
95- sg_table = rd_dev -> sg_table_array ;
96-
97- for (i = 0 ; i < rd_dev -> sg_table_count ; i ++ ) {
88+ for (i = 0 ; i < sg_table_count ; i ++ ) {
9889 sg = sg_table [i ].sg_table ;
9990 sg_per_table = sg_table [i ].rd_sg_count ;
10091
@@ -105,16 +96,28 @@ static void rd_release_device_space(struct rd_dev *rd_dev)
10596 page_count ++ ;
10697 }
10798 }
108-
10999 kfree (sg );
110100 }
111101
102+ kfree (sg_table );
103+ return page_count ;
104+ }
105+
106+ static void rd_release_device_space (struct rd_dev * rd_dev )
107+ {
108+ u32 page_count ;
109+
110+ if (!rd_dev -> sg_table_array || !rd_dev -> sg_table_count )
111+ return ;
112+
113+ page_count = rd_release_sgl_table (rd_dev , rd_dev -> sg_table_array ,
114+ rd_dev -> sg_table_count );
115+
112116 pr_debug ("CORE_RD[%u] - Released device space for Ramdisk"
113117 " Device ID: %u, pages %u in %u tables total bytes %lu\n" ,
114118 rd_dev -> rd_host -> rd_host_id , rd_dev -> rd_dev_id , page_count ,
115119 rd_dev -> sg_table_count , (unsigned long )page_count * PAGE_SIZE );
116120
117- kfree (sg_table );
118121 rd_dev -> sg_table_array = NULL ;
119122 rd_dev -> sg_table_count = 0 ;
120123}
@@ -124,38 +127,15 @@ static void rd_release_device_space(struct rd_dev *rd_dev)
124127 *
125128 *
126129 */
127- static int rd_build_device_space (struct rd_dev * rd_dev )
130+ static int rd_allocate_sgl_table (struct rd_dev * rd_dev , struct rd_dev_sg_table * sg_table ,
131+ u32 total_sg_needed , unsigned char init_payload )
128132{
129- u32 i = 0 , j , page_offset = 0 , sg_per_table , sg_tables , total_sg_needed ;
133+ u32 i = 0 , j , page_offset = 0 , sg_per_table ;
130134 u32 max_sg_per_table = (RD_MAX_ALLOCATION_SIZE /
131135 sizeof (struct scatterlist ));
132- struct rd_dev_sg_table * sg_table ;
133136 struct page * pg ;
134137 struct scatterlist * sg ;
135-
136- if (rd_dev -> rd_page_count <= 0 ) {
137- pr_err ("Illegal page count: %u for Ramdisk device\n" ,
138- rd_dev -> rd_page_count );
139- return - EINVAL ;
140- }
141-
142- /* Don't need backing pages for NULLIO */
143- if (rd_dev -> rd_flags & RDF_NULLIO )
144- return 0 ;
145-
146- total_sg_needed = rd_dev -> rd_page_count ;
147-
148- sg_tables = (total_sg_needed / max_sg_per_table ) + 1 ;
149-
150- sg_table = kzalloc (sg_tables * sizeof (struct rd_dev_sg_table ), GFP_KERNEL );
151- if (!sg_table ) {
152- pr_err ("Unable to allocate memory for Ramdisk"
153- " scatterlist tables\n" );
154- return - ENOMEM ;
155- }
156-
157- rd_dev -> sg_table_array = sg_table ;
158- rd_dev -> sg_table_count = sg_tables ;
138+ unsigned char * p ;
159139
160140 while (total_sg_needed ) {
161141 sg_per_table = (total_sg_needed > max_sg_per_table ) ?
@@ -186,16 +166,59 @@ static int rd_build_device_space(struct rd_dev *rd_dev)
186166 }
187167 sg_assign_page (& sg [j ], pg );
188168 sg [j ].length = PAGE_SIZE ;
169+
170+ p = kmap (pg );
171+ memset (p , init_payload , PAGE_SIZE );
172+ kunmap (pg );
189173 }
190174
191175 page_offset += sg_per_table ;
192176 total_sg_needed -= sg_per_table ;
193177 }
194178
179+ return 0 ;
180+ }
181+
182+ static int rd_build_device_space (struct rd_dev * rd_dev )
183+ {
184+ struct rd_dev_sg_table * sg_table ;
185+ u32 sg_tables , total_sg_needed ;
186+ u32 max_sg_per_table = (RD_MAX_ALLOCATION_SIZE /
187+ sizeof (struct scatterlist ));
188+ int rc ;
189+
190+ if (rd_dev -> rd_page_count <= 0 ) {
191+ pr_err ("Illegal page count: %u for Ramdisk device\n" ,
192+ rd_dev -> rd_page_count );
193+ return - EINVAL ;
194+ }
195+
196+ /* Don't need backing pages for NULLIO */
197+ if (rd_dev -> rd_flags & RDF_NULLIO )
198+ return 0 ;
199+
200+ total_sg_needed = rd_dev -> rd_page_count ;
201+
202+ sg_tables = (total_sg_needed / max_sg_per_table ) + 1 ;
203+
204+ sg_table = kzalloc (sg_tables * sizeof (struct rd_dev_sg_table ), GFP_KERNEL );
205+ if (!sg_table ) {
206+ pr_err ("Unable to allocate memory for Ramdisk"
207+ " scatterlist tables\n" );
208+ return - ENOMEM ;
209+ }
210+
211+ rd_dev -> sg_table_array = sg_table ;
212+ rd_dev -> sg_table_count = sg_tables ;
213+
214+ rc = rd_allocate_sgl_table (rd_dev , sg_table , total_sg_needed , 0x00 );
215+ if (rc )
216+ return rc ;
217+
195218 pr_debug ("CORE_RD[%u] - Built Ramdisk Device ID: %u space of"
196- " %u pages in %u tables\n" , rd_dev -> rd_host -> rd_host_id ,
197- rd_dev -> rd_dev_id , rd_dev -> rd_page_count ,
198- rd_dev -> sg_table_count );
219+ " %u pages in %u tables\n" , rd_dev -> rd_host -> rd_host_id ,
220+ rd_dev -> rd_dev_id , rd_dev -> rd_page_count ,
221+ rd_dev -> sg_table_count );
199222
200223 return 0 ;
201224}
0 commit comments